Add files using upload-large-folder tool

platform/dbops/archive/databases_old/data/workspace/elizabeth_xet_ready/elizabeth_data_20250824_011825/config/.env

@@ -0,0 +1,42 @@
+# Elizabeth Environment Variables
+ELIZABETH_VERSION=v0.0.2
+VLLM_BASE_URL=http://localhost:8
+MODEL_PATH=/workspace/models/qwen3-8b
+
+# Database Connections
+PG_HOST=localhost
+PG_DATABASE=elizabeth_prod
+PG_USER=elizabeth
+PG_PASSWORD=
+
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+MONGO_URI=mongodb://localhost:27017/
+
+# HuggingFace API Configuration - #FRESH - 250705
+HUGGING_FACE_API_KEY=
+HF_TOKEN=
+HF_ORG=LevelUp2x
+
+# Xet Configuration
+XET_REPO_URL=https://xetbeta.com/adaptnova/elizabeth-data
+XET_LOCAL_PATH=/workspace/xet_data
+
+# Search API Keys - Configure for enhanced web search
+FIRECRAWL_API_KEY=fc-94ebc24ae6a4492f9022d6a83001fc54
+TAVILY_API_KEY=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
+SERPER_API_KEY=aace3627d2b7d008f85ce06100984ae7c2a2066f
+
+# Search Configuration
+SEARCH_PROVIDER=firecrawl  # firecrawl, tavily, serper, duckduckgo, perplexity
+SEARCH_MAX_RESULTS=5
+SEARCH_TIMEOUT=30
+
+# Additional Search Services
+PERPLEXITY_API_KEY=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
+
+# Algolia Search Configuration
+ALGOLIA_APPLICATION_ID=H23FYV09PA
+ALGOLIA_SEARCH_API_KEY=7d71ebe7bf1f76a6bb14aecfae798372
+ALGOLIA_WRITE_API_KEY=4d8787832cc1a7920f68df7e791e75bb

platform/dbops/binaries/weaviate-src/test/acceptance/graphql_resolvers/fixtures/actions_schema.json

@@ -0,0 +1,99 @@
+{
+  "version": "0.0.1",
+  "type": "action",
+  "name": "weaviate demo actions schema",
+  "maintainer": "yourfriends@weaviate.com",
+  "classes": [
+    {
+      "class": "Flight",
+      "description": "An airline flight",
+      "properties": [
+        {
+          "name": "aircraft",
+          "dataType": ["Aircraft"],
+          "description": "The kind of aircraft"
+        },
+        {
+          "name": "arrivalAirport",
+          "dataType": ["Airport"],
+          "description": "The airport where the flight terminates"
+        },
+        {
+          "name": "departureAirport",
+          "dataType": ["Airport"],
+          "description": "The airport where the flight originates."
+        },
+        {
+          "name": "flightNumber",
+          "dataType": ["string"],
+          "description": "The unique identifier for a flight"
+        },
+        {
+          "name": "date",
+          "dataType": ["date"],
+          "description": "The date the person is moving"
+        },
+        {
+          "name": "estimatedFlightDuration",
+          "dataType": ["number"],
+          "description": "The estimated time in minutes the flight will take"
+        },
+        {
+          "name": "numberOfPassengers",
+          "dataType": ["int"],
+          "description": "Total number of passengers"
+        },
+        {
+          "name": "isDelayed",
+          "dataType": ["boolean"],
+          "description": "True if the flight is delayed"
+        }
+      ]
+    },
+    {
+      "class": "BuyAction",
+      "description": "An agent buys an object, product, or service from a seller for a price.",
+      "properties": [
+        {
+          "name": "salesPerson",
+          "dataType": ["Airline", "Person"],
+          "description": "The seller of the thing",
+          "keywords": [
+            {"keyword": "sale", "weight": 0.5},
+            {"keyword": "person", "weight": 0.5}
+          ]
+        },
+        {
+          "name": "price",
+          "dataType": ["number"],
+          "description": "The offer price of a product"
+        },
+        {
+          "name": "recipient",
+          "dataType": ["Person"],
+          "description": "The recipient of the good",
+          "keywords": [
+            {"keyword": "buy", "weight": 0.5},
+            {"keyword": "person", "weight": 0.5}
+          ]
+        }
+      ]
+    },
+    {
+      "class": "Event",
+      "description": "Event is used to replicate bugs and prevent regressions for the fixes mentioned in gh-824",
+      "properties": [
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "The name of the event"
+        },
+        {
+          "name": "description",
+          "dataType": ["text"],
+          "description": "The description of the event"
+        }
+      ]
+    }
+  ]
+}

platform/dbops/binaries/weaviate-src/test/acceptance/graphql_resolvers/fixtures/data.json

@@ -0,0 +1,495 @@
+{
+  "Objects": [
+    {
+      "class": "City",
+      "uuid": "001",
+      "name": "Amsterdam",
+      "population": 1800000,
+      "isCapital": true,
+      "inCountry": [
+        {
+          "class": "Country",
+          "uuid": "005",
+          "name": "Netherlands",
+          "population": 17000000
+        }
+      ],
+      "reviews": "Great! A perfect city",
+      "location": {
+        "latitude": 52.366667,
+        "longitude": 4.9
+      }
+    },
+    {
+      "class": "City",
+      "uuid": "002",
+      "name": "Rotterdam",
+      "population": 1800000,
+      "isCapital": false,
+      "inCountry": [
+        {
+          "class": "Country",
+          "uuid": "005",
+          "name": "Netherlands",
+          "population": 17000000
+        }
+      ]
+    },
+    {
+      "class": "City",
+      "uuid": "003",
+      "name": "Berlin",
+      "population": 3470000,
+      "isCapital": true,
+      "reviews": "I had a bad time here",
+      "inCountry": [
+        {
+          "class": "Country",
+          "uuid": "006",
+          "name": "Germany",
+          "population": 83000000
+        }
+      ]
+    },
+    {
+      "class": "City",
+      "uuid": "004",
+      "name": "Dusseldorf",
+      "population": 600000,
+      "isCapital": false,
+      "inCountry": [
+        {
+          "class": "Country",
+          "uuid": "006",
+          "name": "Germany",
+          "population": 83000000
+        }
+      ],
+      "location": {
+        "latitude": 51.225556,
+        "longitude": 6.782778
+      }
+    },
+    {
+      "class": "Country",
+      "uuid": "005",
+      "name": "Netherlands",
+      "population": 17000000
+    },
+    {
+      "class": "Country",
+      "uuid": "006",
+      "name": "Germany",
+      "population": 83000000
+    },
+    {
+      "class": "Person",
+      "uuid": "007",
+      "livesIn": [
+        {
+          "class": "City",
+          "uuid": "004",
+          "name": "Dusseldorf",
+          "population": 600000,
+          "isCapital": false,
+          "inCountry": [
+            {
+              "class": "Country",
+              "uuid": "006",
+              "name": "Germany",
+              "population": 83000000
+            }
+          ]
+        }
+      ],
+      "ofNation": [
+        {
+          "class": "Country",
+          "uuid": "006",
+          "name": "Germany",
+          "population": 83000000
+        }
+      ]
+    },
+    {
+      "class": "Person",
+      "uuid": "008",
+      "livesIn": [
+        {
+          "class": "City",
+          "uuid": "001",
+          "name": "Amsterdam",
+          "population": 1800000,
+          "isCapital": true,
+          "inCountry": {
+            "class": "Country",
+            "uuid": "005",
+            "name": "Netherlands",
+            "population": 17000000
+          }
+        }
+      ],
+      "ofNation": [
+        {
+          "class": "Country",
+          "uuid": "005",
+          "name": "Netherlands",
+          "population": 17000000
+        }
+      ]
+    },
+    {
+      "class": "Airport",
+      "uuid": "009",
+      "inCity": [
+        {
+          "class": "City",
+          "uuid": "001",
+          "name": "Amsterdam",
+          "population": 1800000,
+          "isCapital": true,
+          "inCountry": [
+            {
+              "class": "Country",
+              "uuid": "005",
+              "name": "Netherlands",
+              "population": 17000000
+            }
+          ]
+        }
+      ],
+      "code": "10000"
+    },
+    {
+      "class": "Airport",
+      "uuid": "010",
+      "inCity": [
+        {
+          "class": "City",
+          "uuid": "002",
+          "name": "Rotterdam",
+          "population": 1800000,
+          "isCapital": false,
+          "inCountry": {
+            "class": "Country",
+            "uuid": "005",
+            "name": "Netherlands",
+            "population": 17000000
+          }
+        }
+      ],
+      "code": "20000"
+    },
+    {
+      "class": "Airport",
+      "uuid": "011",
+      "inCity": [
+        {
+          "class": "City",
+          "uuid": "004",
+          "name": "Dusseldorf",
+          "population": 600000,
+          "isCapital": false,
+          "inCountry": {
+            "class": "Country",
+            "uuid": "006",
+            "name": "Germany",
+            "population": 83000000
+          }
+        }
+      ],
+      "code": "30000"
+    },
+    {
+      "class": "Airport",
+      "uuid": "012",
+      "inCity": [
+        {
+          "class": "City",
+          "uuid": "003",
+          "name": "Berlin",
+          "population": 3470000,
+          "isCapital": true,
+          "inCountry": {
+            "class": "Country",
+            "uuid": "006",
+            "name": "Germany",
+            "population": 83000000
+          }
+        }
+      ],
+      "code": "40000"
+    },
+    {
+      "class": "Airline",
+      "uuid": "013",
+      "name": "Lufthansa",
+      "basedIn": [
+        {
+          "class": "City",
+          "uuid": "003",
+          "name": "Berlin",
+          "population": 3470000,
+          "isCapital": true,
+          "inCountry": {
+            "class": "Country",
+            "uuid": "006",
+            "name": "Germany",
+            "population": 83000000
+          }
+        }
+      ],
+      "code": "123"
+    },
+    {
+      "class": "Airline",
+      "uuid": "014",
+      "name": "KLM",
+      "basedIn": [
+        {
+          "class": "City",
+          "uuid": "001",
+          "name": "Amsterdam",
+          "population": 1800000,
+          "isCapital": true,
+          "inCountry": {
+            "class": "Country",
+            "uuid": "005",
+            "name": "Netherlands",
+            "population": 17000000
+          }
+        }
+      ],
+      "code": "321"
+    },
+    {
+      "class": "Aircraft",
+      "uuid": "015",
+      "name": "Boeing 747",
+      "numberOfSeats": 366
+    },
+    {
+      "class": "Aircraft",
+      "uuid": "016",
+      "name": "Airbus A380",
+      "numberOfSeats": 853
+    },
+    {
+      "class": "Plane",
+      "uuid": "017",
+      "code": "AB123",
+      "aircraft": [
+        {
+          "class": "Aircraft",
+          "uuid": "015",
+          "name": "Boeing 747",
+          "numberOfSeats": 366
+        }
+      ],
+      "ofAirline": [
+        {
+          "class": "Airline",
+          "uuid": "013",
+          "name": "Lufthansa",
+          "basedIn": {
+            "class": "City",
+            "uuid": "003",
+            "name": "Berlin",
+            "population": 3470000,
+            "isCapital": true,
+            "inCountry": {
+              "class": "Country",
+              "uuid": "006",
+              "name": "Germany",
+              "population": 83000000
+            }
+          },
+          "code": "123"
+        }
+      ]
+    },
+    {
+      "class": "Plane",
+      "uuid": "018",
+      "code": "AB456",
+      "aircraft": [
+        {
+          "class": "Aircraft",
+          "uuid": "016",
+          "name": "Airbus A380",
+          "numberOfSeats": 853
+        }
+      ],
+      "ofAirline": [
+        {
+          "class": "Airline",
+          "uuid": "014",
+          "name": "KLM",
+          "basedIn": {
+            "class": "City",
+            "uuid": "001",
+            "name": "Amsterdam",
+            "population": 1800000,
+            "isCapital": true,
+            "inCountry": {
+              "class": "Country",
+              "uuid": "005",
+              "name": "Netherlands",
+              "population": 17000000
+            }
+          },
+          "code": "321"
+        }
+      ]
+    },
+    {
+      "class": "Plane",
+      "uuid": "019",
+      "code": "AB457",
+      "aircraft": [
+        {
+          "class": "Aircraft",
+          "uuid": "015",
+          "name": "Boeing 747",
+          "numberOfSeats": 366
+        }
+      ],
+      "ofAirline": [
+        {
+          "class": "Airline",
+          "uuid": "014",
+          "name": "KLM",
+          "basedIn": [
+            {
+              "class": "City",
+              "uuid": "001",
+              "name": "Amsterdam",
+              "population": 1800000,
+              "isCapital": true,
+              "inCountry": [
+                {
+                  "class": "Country",
+                  "uuid": "005",
+                  "name": "Netherlands",
+                  "population": 17000000
+                }
+              ]
+            }
+          ],
+          "code": "321"
+        }
+      ]
+    },
+    {
+      "class": "Plane",
+      "uuid": "020",
+      "code": "AB456",
+      "aircraft": [
+        {
+          "class": "Aircraft",
+          "uuid": "016",
+          "name": "Airbus A380",
+          "numberOfSeats": 853
+        }
+      ],
+      "ofAirline": [
+        {
+          "class": "Airline",
+          "uuid": "013",
+          "name": "Lufthansa",
+          "basedIn": [
+            {
+              "class": "City",
+              "uuid": "003",
+              "name": "Berlin",
+              "population": 3470000,
+              "isCapital": true,
+              "inCountry": [
+                {
+                  "class": "Country",
+                  "uuid": "006",
+                  "name": "Germany",
+                  "population": 83000000
+                }
+              ]
+            }
+          ],
+          "code": "123"
+        }
+      ]
+    }
+  ],
+  "Actions": [
+    {
+      "class": "Event",
+      "uuid": "021",
+      "name": "A name"
+    },
+    {
+      "class": "Event",
+      "uuid": "022",
+      "description": "A desricption"
+    },
+    {
+      "class": "Flight",
+      "uuid": "100",
+      "aircraft": [
+        {
+          "class": "Aircraft",
+          "uuid": "016",
+          "name": "Airbus A380",
+          "numberOfSeats": 853
+        }
+      ],
+      "arrivalAirport": [
+        {
+          "class": "Airport",
+          "uuid": "011",
+          "inCity": [
+            {
+              "class": "City",
+              "uuid": "004",
+              "name": "Dusseldorf",
+              "population": 600000,
+              "isCapital": false,
+              "inCountry": {
+                "class": "Country",
+                "uuid": "006",
+                "name": "Germany",
+                "population": 83000000
+              }
+            }
+          ],
+          "code": "30000"
+        }
+      ],
+      "departureAirport": [
+        {
+          "class": "Airport",
+          "uuid": "012",
+          "inCity": [
+            {
+              "class": "City",
+              "uuid": "003",
+              "name": "Berlin",
+              "population": 3470000,
+              "isCapital": true,
+              "inCountry": {
+                "class": "Country",
+                "uuid": "006",
+                "name": "Germany",
+                "population": 83000000
+              }
+            }
+          ],
+          "code": "40000"
+        }
+      ],
+      "flightNumber": "LH987",
+      "date": "2017-08-17T12:47:00+02:00",
+      "estimatedFlightDuration": 50,
+      "numberOfPassengers": 300,
+      "isDelayed": false
+    }
+  ]
+}

platform/dbops/binaries/weaviate-src/test/acceptance/graphql_resolvers/fixtures/things_schema.json

@@ -0,0 +1,177 @@
+{
+  "@context": "",
+  "version": "0.0.1",
+  "type": "object",
+  "name": "weaviate demo objects schema",
+  "maintainer": "yourfriends@weaviate.com",
+  "classes": [
+    {
+      "class": "City",
+      "description": "A city, place or town",
+      "properties": [
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "Official name of the city."
+        },
+        {
+          "name": "inCountry",
+          "dataType": ["Country"],
+          "description": "The country the city lies in"
+        },
+        {
+          "name": "population",
+          "dataType": ["int"],
+          "description": "Number of inhabitants of the city"
+        },
+        {
+          "name": "isCapital",
+          "dataType": ["boolean"],
+          "description": "True if the city is a capital"
+        },
+        {
+          "name": "reviews",
+          "dataType": ["string"],
+          "description": "Visitors opinions about the city"
+        },
+        {
+          "name": "location",
+          "dataType": ["geoCoordinates"],
+          "description": "The city's longitude and latitude",
+          "keywords": [{"keyword": "location", "weight": 1.0}]
+        }
+      ]
+    },
+    {
+      "class": "Person",
+      "description": "Person",
+      "properties": [
+        {
+          "name": "livesIn",
+          "dataType": ["City"],
+          "description": "The place where the person lives in."
+        },
+        {
+          "name": "birthday",
+          "dataType": ["date"],
+          "description": "Birthday of the person"
+        },
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "Name of the person"
+        },
+        {
+          "name": "ofNation",
+          "dataType": ["Country"],
+          "description": "Nationality of the person",
+          "keywords": [
+            {"keyword": "nation", "weight": 1.0},
+            {"keyword": "country", "weight": 1.0},
+            {"keyword": "person", "weight": 1.0}
+          ]
+        }
+      ]
+    },
+    {
+      "class": "Country",
+      "description": "Country",
+      "properties": [
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "Official name of the country"
+        },
+        {
+          "name": "population",
+          "dataType": ["int"],
+          "description": "Amount of people living in the country"
+        }
+      ]
+    },
+    {
+      "class": "Airport",
+      "description": "An airport",
+      "properties": [
+        {
+          "name": "code",
+          "dataType": ["string"],
+          "description": "identifier for an airport"
+        },
+        {
+          "name": "inCity",
+          "dataType": ["City"],
+          "description": "City where the airport lies."
+        },
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "Official name of the airport"
+        }
+      ]
+    },
+    {
+      "class": "Airline",
+      "description": "An organization that provides flights for passengers",
+      "properties": [
+        {
+          "name": "code",
+          "dataType": ["string"],
+          "description": "identifier for an airport"
+        },
+        {
+          "name": "basedIn",
+          "dataType": ["City", "Country"],
+          "description": "City or country where the airline is based."
+        },
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "Official name of the airline"
+        },
+        {
+          "name": "hasNumberOfPlanes",
+          "dataType": ["int"],
+          "description": "Number of airplanes the airline owns"
+        }
+      ]
+    },
+    {
+      "class": "Plane",
+      "description": "An airplane",
+      "properties": [
+        {
+          "name": "code",
+          "dataType": ["string"],
+          "description": "identifier for the plane"
+        },
+        {
+          "name": "aircraft",
+          "dataType": ["Aircraft"],
+          "description": "the kind of aircraft"
+        },
+        {
+          "name": "ofAirline",
+          "dataType": ["Airline"],
+          "description": "Airline the plane is owned by"
+        }
+      ]
+    },
+    {
+      "class": "Aircraft",
+      "description": "The kind of aircraft (e.g., \"Boeing 747\")",
+      "properties": [
+        {
+          "name": "name",
+          "dataType": ["string"],
+          "description": "name of the aircraft"
+        },
+        {
+          "name": "numberOfSeats",
+          "dataType": ["number"],
+          "description": "number of seats available in the aircraft."
+        }
+      ]
+    }
+  ]
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/async_replication/async_repair_deletes_test.go

@@ -0,0 +1,120 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/acceptance/replication/common"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *AsyncReplicationTestSuite) TestAsyncRepairObjectDeleteScenario() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	clusterSize := 3
+
+	compose, err := docker.New().
+		WithWeaviateCluster(clusterSize).
+		WithText2VecContextionary().
+		Start(mainCtx)
+	require.Nil(t, err)
+	defer func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(mainCtx, 15*time.Minute)
+	defer cancel()
+
+	paragraphClass := articles.ParagraphsClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:           int64(clusterSize),
+			DeletionStrategy: models.ReplicationConfigDeletionStrategyTimeBasedResolution,
+			AsyncEnabled:     true,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.CreateClass(t, paragraphClass)
+	})
+
+	paragraphCount := len(paragraphIDs)
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, paragraphCount)
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+
+		common.CreateObjectsCL(t, compose.GetWeaviate().URI(), batch, types.ConsistencyLevelAll)
+	})
+
+	node := 2
+
+	t.Run(fmt.Sprintf("stop node %d", node), func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, node)
+	})
+
+	host := compose.GetWeaviate().URI()
+	helper.SetupClient(host)
+
+	for _, id := range paragraphIDs {
+		helper.DeleteObjectCL(t, paragraphClass.Class, id, types.ConsistencyLevelQuorum)
+	}
+
+	t.Run(fmt.Sprintf("restart node %d", node), func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, node)
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			verbose := verbosity.OutputVerbose
+			params := nodes.NewNodesGetClassParams().WithOutput(&verbose)
+			body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+			require.NoError(ct, clientErr)
+			require.NotNil(ct, body.Payload)
+
+			resp := body.Payload
+			require.Len(ct, resp.Nodes, clusterSize)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				require.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	t.Run(fmt.Sprintf("all the objects should have been deleted from node %d", node), func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			resp := common.GQLGet(t, compose.ContainerURI(node), "Paragraph", types.ConsistencyLevelOne)
+			require.Len(ct, resp, 0)
+		}, 120*time.Second, 5*time.Second, "not all the objects have been asynchronously replicated")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/async_replication/async_repair_insertions_test.go

@@ -0,0 +1,109 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/acceptance/replication/common"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+func (suite *AsyncReplicationTestSuite) TestAsyncRepairObjectInsertionScenario() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	clusterSize := 3
+
+	compose, err := docker.New().
+		WithWeaviateCluster(clusterSize).
+		WithText2VecContextionary().
+		Start(mainCtx)
+	require.Nil(t, err)
+	defer func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(mainCtx, 15*time.Minute)
+	defer cancel()
+
+	paragraphClass := articles.ParagraphsClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       int64(clusterSize),
+			AsyncEnabled: true,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.CreateClass(t, paragraphClass)
+	})
+
+	node := 2
+
+	t.Run(fmt.Sprintf("stop node %d", node), func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, node)
+	})
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+
+		common.CreateObjectsCL(t, compose.GetWeaviate().URI(), batch, types.ConsistencyLevelOne)
+	})
+
+	t.Run(fmt.Sprintf("restart node %d", node), func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, node)
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			verbose := verbosity.OutputVerbose
+			params := nodes.NewNodesGetClassParams().WithOutput(&verbose)
+			body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+			require.NoError(ct, clientErr)
+			require.NotNil(ct, body.Payload)
+
+			resp := body.Payload
+			require.Len(ct, resp.Nodes, clusterSize)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				require.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	t.Run(fmt.Sprintf("assert node %d has all the objects", node), func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			resp := common.GQLGet(t, compose.ContainerURI(node), "Paragraph", types.ConsistencyLevelOne)
+			require.Len(ct, resp, len(paragraphIDs))
+		}, 120*time.Second, 5*time.Second, "not all the objects have been asynchronously replicated")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/async_replication/async_repair_multi_tenancy_test.go

@@ -0,0 +1,141 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/acceptance/replication/common"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+// In this scenario, we are testing two things:
+//
+//  1. The invocation of shard.UpdateAsyncReplication on an index with inactive tenants,
+//     using ForEachLoadedShard to avoid force loading shards for the purpose of enabling
+//     async replication, ensuring that if it is enabled when some tenants are inactive,
+//     that the change is correctly applied to the tenants if they are later activated
+//
+//  2. That once (1) occurs, the hashBeat process is correctly initiated at the time that
+//     the tenant is activated, and any missing objects are successfully propagated to the
+//     nodes which are missing them.
+//
+// The actual scenario is as follows:
+//   - Create a class with multi-tenancy enabled, replicated by a factor of 3
+//   - Create a tenant, and set it to inactive
+//   - Stop the second node
+//   - Activate the tenant, and insert 1000 objects into the 2 surviving nodes
+//   - Restart the second node and ensure it has an object count of 0
+//   - Update the class to enabled async replication
+//   - Wait a few seconds for objects to propagate
+//   - Verify that the resurrected node contains all objects
+func (suite *AsyncReplicationTestSuite) TestAsyncRepairMultiTenancyScenario() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	var (
+		clusterSize = 3
+		tenantName  = "tenant-0"
+		objectCount = 100
+	)
+
+	compose, err := docker.New().
+		WithWeaviateCluster(clusterSize).
+		WithText2VecContextionary().
+		Start(mainCtx)
+	require.Nil(t, err)
+	defer func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(mainCtx, 15*time.Minute)
+	defer cancel()
+
+	paragraphClass := articles.ParagraphsClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       int64(clusterSize),
+			AsyncEnabled: true,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		paragraphClass.MultiTenancyConfig = &models.MultiTenancyConfig{
+			AutoTenantActivation: true,
+			Enabled:              true,
+		}
+
+		helper.SetupClient(compose.GetWeaviate().URI())
+		helper.CreateClass(t, paragraphClass)
+	})
+
+	t.Run("add inactive tenant", func(t *testing.T) {
+		tenants := []*models.Tenant{{Name: tenantName, ActivityStatus: "COLD"}}
+		helper.CreateTenants(t, paragraphClass.Class, tenants)
+	})
+
+	t.Run("stop node 2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	// Activate/insert tenants while node 2 is down
+	t.Run("activate tenant and insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, objectCount)
+		for i := 0; i < objectCount; i++ {
+			batch[i] = articles.NewParagraph().
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				WithTenant(tenantName).
+				Object()
+		}
+		common.CreateObjectsCL(t, compose.GetWeaviate().URI(), batch, types.ConsistencyLevelOne)
+	})
+
+	t.Run("start node 2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			verbose := verbosity.OutputVerbose
+			params := nodes.NewNodesGetClassParams().WithOutput(&verbose)
+			body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+			require.NoError(ct, clientErr)
+			require.NotNil(ct, body.Payload)
+
+			resp := body.Payload
+			require.Len(ct, resp.Nodes, clusterSize)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				require.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	t.Run("validate async object propagation", func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			resp := common.GQLTenantGet(t, compose.GetWeaviateNode(2).URI(), paragraphClass.Class, types.ConsistencyLevelOne, tenantName)
+			require.Len(ct, resp, objectCount)
+		}, 120*time.Second, 5*time.Second, "not all the objects have been asynchronously replicated")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/replication/async_replication/async_repair_test.go

@@ -0,0 +1,241 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package replication
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/go-openapi/strfmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"github.com/weaviate/weaviate/client/nodes"
+	"github.com/weaviate/weaviate/cluster/router/types"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/verbosity"
+	"github.com/weaviate/weaviate/test/acceptance/replication/common"
+	"github.com/weaviate/weaviate/test/docker"
+	"github.com/weaviate/weaviate/test/helper"
+	"github.com/weaviate/weaviate/test/helper/sample-schema/articles"
+)
+
+var (
+	paragraphIDs = []strfmt.UUID{
+		strfmt.UUID("3bf331ac-8c86-4f95-b127-2f8f96bbc093"),
+		strfmt.UUID("47b26ba1-6bc9-41f8-a655-8b9a5b60e1a3"),
+		strfmt.UUID("5fef6289-28d2-4ea2-82a9-48eb501200cd"),
+		strfmt.UUID("34a673b4-8859-4cb4-bb30-27f5622b47e9"),
+		strfmt.UUID("9fa362f5-c2dc-4fb8-b5b2-11701adc5f75"),
+		strfmt.UUID("63735238-6723-4caf-9eaa-113120968ff4"),
+		strfmt.UUID("2236744d-b2d2-40e5-95d8-2574f20a7126"),
+		strfmt.UUID("1a54e25d-aaf9-48d2-bc3c-bef00b556297"),
+		strfmt.UUID("0b8a0e70-a240-44b2-ac6d-26dda97523b9"),
+		strfmt.UUID("50566856-5d0a-4fb1-a390-e099bc236f66"),
+	}
+
+	articleIDs = []strfmt.UUID{
+		strfmt.UUID("aeaf8743-5a8f-4149-b960-444181d3131a"),
+		strfmt.UUID("2a1e9834-064e-4ca8-9efc-35707c6bae6d"),
+		strfmt.UUID("8d101c0c-4deb-48d0-805c-d9c691042a1a"),
+		strfmt.UUID("b9715fec-ef6c-4e8d-a89e-55e2eebee3f6"),
+		strfmt.UUID("faf520f2-f6c3-4cdf-9c16-0348ffd0f8ac"),
+		strfmt.UUID("d4c695dd-4dc7-4e49-bc73-089ef5f90fc8"),
+		strfmt.UUID("c7949324-e07f-4ffc-8be0-194f0470d375"),
+		strfmt.UUID("9c112e01-7759-43ed-a6e8-5defb267c8ee"),
+		strfmt.UUID("9bf847f3-3a1a-45a5-b656-311163e536b5"),
+		strfmt.UUID("c1975388-d67c-404a-ae77-5983fbaea4bb"),
+	}
+)
+
+type AsyncReplicationTestSuite struct {
+	suite.Suite
+}
+
+func (suite *AsyncReplicationTestSuite) SetupTest() {
+	suite.T().Setenv("TEST_WEAVIATE_IMAGE", "weaviate/test-server")
+}
+
+func TestAsyncReplicationTestSuite(t *testing.T) {
+	suite.Run(t, new(AsyncReplicationTestSuite))
+}
+
+func (suite *AsyncReplicationTestSuite) TestAsyncRepairSimpleScenario() {
+	t := suite.T()
+	mainCtx := context.Background()
+
+	compose, err := docker.New().
+		WithWeaviateCluster(3).
+		WithText2VecContextionary().
+		Start(mainCtx)
+	require.Nil(t, err)
+	defer func() {
+		if err := compose.Terminate(mainCtx); err != nil {
+			t.Fatalf("failed to terminate test containers: %s", err.Error())
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(mainCtx, 10*time.Minute)
+	defer cancel()
+
+	helper.SetupClient(compose.GetWeaviate().URI())
+	paragraphClass := articles.ParagraphsClass()
+	articleClass := articles.ArticlesClass()
+
+	t.Run("create schema", func(t *testing.T) {
+		paragraphClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       3,
+			AsyncEnabled: true,
+		}
+		paragraphClass.Vectorizer = "text2vec-contextionary"
+		helper.CreateClass(t, paragraphClass)
+		articleClass.ReplicationConfig = &models.ReplicationConfig{
+			Factor:       3,
+			AsyncEnabled: true,
+		}
+		helper.CreateClass(t, articleClass)
+	})
+
+	t.Run("insert paragraphs", func(t *testing.T) {
+		batch := make([]*models.Object, len(paragraphIDs))
+		for i, id := range paragraphIDs {
+			batch[i] = articles.NewParagraph().
+				WithID(id).
+				WithContents(fmt.Sprintf("paragraph#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviate().URI(), batch)
+	})
+
+	t.Run("insert articles", func(t *testing.T) {
+		batch := make([]*models.Object, len(articleIDs))
+		for i, id := range articleIDs {
+			batch[i] = articles.NewArticle().
+				WithID(id).
+				WithTitle(fmt.Sprintf("Article#%d", i)).
+				Object()
+		}
+		common.CreateObjects(t, compose.GetWeaviateNode(2).URI(), batch)
+	})
+
+	t.Run("stop node 3", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 3)
+	})
+
+	repairObj := models.Object{
+		ID:    "e5390693-5a22-44b8-997d-2a213aaf5884",
+		Class: "Paragraph",
+		Properties: map[string]interface{}{
+			"contents": "a new paragraph",
+		},
+	}
+
+	t.Run("add new object to node one", func(t *testing.T) {
+		common.CreateObjectCL(t, compose.GetWeaviate().URI(), &repairObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 3", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 3)
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			verbose := verbosity.OutputVerbose
+			params := nodes.NewNodesGetClassParams().WithOutput(&verbose)
+			body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+			require.NoError(ct, clientErr)
+			require.NotNil(ct, body.Payload)
+
+			resp := body.Payload
+			require.Len(ct, resp.Nodes, 3)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				assert.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	t.Run("assert new object read repair was made", func(t *testing.T) {
+		assert.EventuallyWithT(t, func(ct *assert.CollectT) {
+			resp, err := common.GetObjectCL(t, compose.GetWeaviateNode(3).URI(),
+				repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+			assert.Nil(ct, err)
+			assert.NotNil(ct, resp)
+			if resp == nil {
+				return
+			}
+			assert.Equal(ct, repairObj.ID, resp.ID)
+			assert.Equal(ct, repairObj.Class, resp.Class)
+			assert.EqualValues(ct, repairObj.Properties, resp.Properties)
+			assert.EqualValues(ct, repairObj.Vector, resp.Vector)
+		}, 60*time.Second, 1*time.Second, "not all the objects have been asynchronously replicated")
+	})
+
+	replaceObj := repairObj
+	replaceObj.Properties = map[string]interface{}{
+		"contents": "this paragraph was replaced",
+	}
+
+	t.Run("stop node 2", func(t *testing.T) {
+		common.StopNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("replace object", func(t *testing.T) {
+		common.UpdateObjectCL(t, compose.GetWeaviateNode(3).URI(), &replaceObj, types.ConsistencyLevelOne)
+	})
+
+	t.Run("restart node 2", func(t *testing.T) {
+		common.StartNodeAt(ctx, t, compose, 2)
+	})
+
+	t.Run("verify that all nodes are running", func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			verbose := verbosity.OutputVerbose
+			params := nodes.NewNodesGetClassParams().WithOutput(&verbose)
+			body, clientErr := helper.Client(t).Nodes.NodesGetClass(params, nil)
+			require.NoError(ct, clientErr)
+			require.NotNil(ct, body.Payload)
+
+			resp := body.Payload
+			require.Len(ct, resp.Nodes, 3)
+			for _, n := range resp.Nodes {
+				require.NotNil(ct, n.Status)
+				require.Equal(ct, "HEALTHY", *n.Status)
+			}
+		}, 15*time.Second, 500*time.Millisecond)
+	})
+
+	t.Run("assert updated object read repair was made", func(t *testing.T) {
+		require.EventuallyWithT(t, func(ct *assert.CollectT) {
+			exists, err := common.ObjectExistsCL(t, compose.GetWeaviateNode(2).URI(),
+				replaceObj.Class, replaceObj.ID, types.ConsistencyLevelOne)
+			require.Nil(ct, err)
+			require.True(ct, exists)
+
+			resp, err := common.GetObjectCL(t, compose.GetWeaviate().URI(),
+				repairObj.Class, repairObj.ID, types.ConsistencyLevelOne)
+			require.Nil(ct, err)
+			require.NotNil(ct, resp)
+
+			if resp == nil {
+				return
+			}
+
+			require.Equal(ct, replaceObj.ID, resp.ID)
+			require.Equal(ct, replaceObj.Class, resp.Class)
+			require.EqualValues(ct, replaceObj.Properties, resp.Properties)
+			require.EqualValues(ct, replaceObj.Vector, resp.Vector)
+		}, 120*time.Second, 5*time.Second, "not all the objects have been asynchronously replicated")
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/stress_tests/tenants_test.go

@@ -0,0 +1,112 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package stress_tests
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func TestConcurrentTenantsAddAndRemove(t *testing.T) {
+	url := "http://localhost:8080/v1/"
+
+	c := createHttpClient()
+	clearExistingObjects(c, url)
+	requestSchema := createSchemaRequest(url, class, true)
+
+	performRequest(c, requestSchema)
+
+	// Add schema and object
+	parallelReqs := 50
+	wg := sync.WaitGroup{}
+	wgStartReqests := sync.WaitGroup{}
+	wgStartReqests.Add(parallelReqs)
+	wg.Add(parallelReqs)
+
+	for i := 0; i < parallelReqs; i++ {
+		go func(j int) {
+			c := createHttpClient()
+
+			requestAddTenant := createRequest(url+"schema/"+class+"/tenants", "POST", []models.Tenant{{Name: "tenant" + fmt.Sprint(j)}})
+			requestDeleteTenant := createRequest(url+"schema/"+class+"/tenants", "DELETE", []string{"tenant" + fmt.Sprint(j)})
+
+			wgStartReqests.Done()
+			wgStartReqests.Wait()
+			performRequest(c, requestAddTenant)
+			performRequest(c, requestDeleteTenant)
+
+			wg.Done()
+		}(i)
+	}
+	wg.Wait()
+
+	requestGetTenants := createRequest(url+"schema/"+class+"/tenants", "GET", nil)
+
+	_, body, _ := performRequest(c, requestGetTenants)
+	var result []*models.Tenant
+	json.Unmarshal(body, &result)
+	assert.Equal(t, 0, len(result))
+}
+
+func TestConcurrentTenantBatchesWithTenantAdd(t *testing.T) {
+	url := "http://localhost:8080/v1/"
+
+	c := createHttpClient()
+	clearExistingObjects(c, url)
+
+	tenants := make([]models.Tenant, 10)
+	for i := 0; i < len(tenants); i++ {
+		tenants[i] = models.Tenant{Name: "tenant" + fmt.Sprint(i)}
+	}
+
+	nrClasses := 10
+	for i := 0; i < nrClasses; i++ {
+		performRequest(c, createSchemaRequest(url, class+fmt.Sprint(i), true))
+		performRequest(c, createRequest(url+"schema/"+class+fmt.Sprint(i)+"/tenants", "POST", tenants))
+	}
+
+	// Add schema and object
+	parallelReqs := 20
+	wg := sync.WaitGroup{}
+	wgStartReqests := sync.WaitGroup{}
+	wgStartReqests.Add(parallelReqs)
+	wg.Add(parallelReqs)
+
+	batchSize := 100
+
+	for i := 0; i < parallelReqs; i++ {
+		go func(j int) {
+			c := createHttpClient()
+
+			requestBatch := createRequest(url+"batch/objects", "POST", batch{createBatch(class+fmt.Sprint(j%nrClasses), batchSize, tenants)})
+
+			wgStartReqests.Done()
+			wgStartReqests.Wait()
+			performRequest(c, requestBatch)
+			wg.Done()
+		}(i)
+	}
+	wg.Wait()
+
+	// check for one class that we have the expected nr of objects per tenant
+	requestRead := createRequest(url+fmt.Sprintf("objects?limit=%v&class="+class+"%s&tenant=%s", 1000, "4", fmt.Sprint(tenants[0].Name)), "GET", nil)
+	_, body, _ := performRequest(c, requestRead)
+	var result map[string]interface{}
+	json.Unmarshal(body, &result)
+	assert.Equal(t, parallelReqs/nrClasses*batchSize/len(tenants), int(result["totalResults"].(float64))) // batches per class, * objects per batch/nr_tenants
+	clearExistingObjects(c, url)
+}

platform/dbops/binaries/weaviate-src/test/acceptance/telemetry/logging_test.go

@@ -0,0 +1,130 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+// TODO gh-1232 remove
+// // This test covers the Telemetry process. Weaviate should log each time its endpoints are accessed,
+// // and it should send these logs to an endpoint. In the testing config environment this endpoint is
+// // the mock api's address. This test sends a request to Weaviate to ensure at least one log *should*
+// // exist, waits a few seconds to ensure the log *should* be sent to the mock endpoint and then retrieves
+// // the most recently received log from the mock endpoint. The test then decodes the response and
+// // validates its structure.
+// //
+// // controlled by setup_test.go
+// func createActionLogging(t *testing.T) {
+// 	// send a request
+// 	sendCreateActionRequest(t)
+
+// 	// wait for the log to be posted
+// 	time.Sleep(7 * time.Second)
+
+// 	result := retrieveLogFromMockEndpoint(t)
+
+// 	if result != nil {
+// 		interpretedResult := interpretResult(t, result)
+// 		if interpretedResult != nil {
+// 			_, namePresent := interpretedResult["n"]
+// 			_, typePresent := interpretedResult["t"]
+// 			_, identifierPresent := interpretedResult["i"]
+// 			_, amountPresent := interpretedResult["a"]
+// 			_, whenPresent := interpretedResult["w"]
+
+// 			assert.Equal(t, true, namePresent)
+// 			assert.Equal(t, true, typePresent)
+// 			assert.Equal(t, true, identifierPresent)
+// 			assert.Equal(t, true, amountPresent)
+// 			assert.Equal(t, true, whenPresent)
+
+// 		}
+// 	}
+// }
+
+// // The sendCreateActionRequest acceptance test is copied here to ensure at least one request should be
+// // logged when we check the mock api's most recently received request. These assertions should pass
+// // regardless of the rest of the Telemetry test passing.
+// func sendCreateActionRequest(t *testing.T) {
+// 	// Set all action values to compare
+// 	actionTestString := "Test string"
+// 	actionTestInt := 1
+// 	actionTestBoolean := true
+// 	actionTestNumber := 1.337
+// 	actionTestDate := "2017-10-06T08:15:30+01:00"
+
+// 	params := actions.NewActionsCreateParams().WithBody(
+// 		&models.Action{
+// 			Class: "MonitoringTestAction",
+// 			Schema: map[string]interface{}{
+// 				"testString":      actionTestString,
+// 				"testWholeNumber": actionTestInt,
+// 				"testTrueFalse":   actionTestBoolean,
+// 				"testNumber":      actionTestNumber,
+// 				"testDateTime":    actionTestDate,
+// 			},
+// 		})
+
+// 	resp, err := helper.Client(t).Actions.ActionsCreate(params, nil)
+
+// 	// Ensure that the response is OK.
+// 	helper.AssertRequestOk(t, resp, err, func() {
+// 		action := resp.Payload
+// 		assert.Regexp(t, strfmt.UUIDPattern, action.ID)
+
+// 		schema, ok := action.Schema.(map[string]interface{})
+// 		if !ok {
+// 			t.Fatal("The returned schema is not an JSON object")
+// 		}
+
+// 		testWholeNumber, _ := schema["testWholeNumber"].(json.Number).Int64()
+// 		testNumber, _ := schema["testNumber"].(json.Number).Float64()
+
+// 		// Check whether the returned information is the same as the data added.
+// 		assert.Equal(t, actionTestString, schema["testString"])
+// 		assert.Equal(t, actionTestInt, int(testWholeNumber))
+// 		assert.Equal(t, actionTestBoolean, schema["testTrueFalse"])
+// 		assert.Equal(t, actionTestNumber, testNumber)
+// 		assert.Equal(t, actionTestDate, schema["testDateTime"])
+// 	})
+// }
+
+// // retrieveLogFromMockEndpoint retrieves the most recently received log from the mock api.
+// func retrieveLogFromMockEndpoint(t *testing.T) []byte {
+// 	req, err := http.NewRequest("GET", "http://localhost:8087/mock/last", nil)
+// 	req.Close = true
+// 	assert.Equal(t, nil, err)
+
+// 	client := &http.Client{}
+// 	resp, err := client.Do(req)
+// 	if err == nil {
+// 		body, _ := io.ReadAll(resp.Body)
+// 		defer resp.Body.Close()
+// 		return body
+// 	}
+// 	if err != nil {
+// 		urlError, ok := err.(*url.Error)
+// 		if ok {
+// 			assert.Equal(t, nil, urlError.Op)
+// 		}
+// 	}
+
+// 	return nil
+// }
+
+// // interpretResult converts the received cbor-encoded log to a []map[string]interface.
+// func interpretResult(t *testing.T, resultBody []byte) map[string]interface{} {
+// 	decoded := make([]map[string]interface{}, 1)
+// 	cborHandle := new(codec.CborHandle)
+// 	encoder := codec.NewDecoderBytes(resultBody, cborHandle)
+// 	err := encoder.Decode(&decoded)
+
+// 	require.Equal(t, nil, err)
+// 	return decoded[0]
+// }

platform/dbops/binaries/weaviate-src/test/acceptance/telemetry/setup_test.go

@@ -0,0 +1,70 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+// TODO gh-1232: remove
+// import (
+// 	"testing"
+
+// 	"github.com/weaviate/weaviate/client/schema"
+// 	"github.com/weaviate/weaviate/entities/models"
+// 	"github.com/weaviate/weaviate/test/helper"
+// )
+
+// func Test_Actions(t *testing.T) {
+// 	t.Run("setup", func(t *testing.T) {
+// 		createActionClass(t, &models.Class{
+// 			Class: "MonitoringTestAction",
+// 			Properties: []*models.Property{
+// 				&models.Property{
+// 					Name:     "testString",
+// DataType:     schema.DataTypeText.PropString(),
+// Tokenization: models.PropertyTokenizationWhitespace,
+// 				},
+// 				&models.Property{
+// 					Name:     "testWholeNumber",
+// 					DataType: []string{"int"},
+// 				},
+// 				&models.Property{
+// 					Name:     "testNumber",
+// 					DataType: []string{"number"},
+// 				},
+// 				&models.Property{
+// 					Name:     "testDateTime",
+// 					DataType: []string{"date"},
+// 				},
+// 				&models.Property{
+// 					Name:     "testTrueFalse",
+// 					DataType: []string{"boolean"},
+// 				},
+// 			},
+// 		})
+// 	})
+
+// 	// tests
+// 	t.Run("create action logging", createActionLogging)
+
+// 	// tear down
+// 	deleteActionClass(t, "MonitoringTestAction")
+// }
+
+// func createActionClass(t *testing.T, class *models.Class) {
+// 	params := schema.NewCollectionsActionsCreateParams().WithActionClass(class)
+// 	resp, err := helper.Client(t).Schema.CollectionsActionsCreate(params, nil)
+// 	helper.AssertRequestOk(t, resp, err, nil)
+// }
+
+// func deleteActionClass(t *testing.T, class string) {
+// 	delParams := schema.NewCollectionsActionsDeleteParams().WithClassName(class)
+// 	delRes, err := helper.Client(t).Schema.CollectionsActionsDelete(delParams, nil)
+// 	helper.AssertRequestOk(t, delRes, err, nil)
+// }

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/cosine_test.go

@@ -0,0 +1,559 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func addTestDataCosine(t *testing.T) {
+	createObject(t, &models.Object{
+		Class: "Cosine_Class",
+		Properties: map[string]interface{}{
+			"name": "object_1",
+		},
+		Vector: []float32{
+			0.7, 0.3, // our base object
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Cosine_Class",
+		Properties: map[string]interface{}{
+			"name": "object_2",
+		},
+		Vector: []float32{
+			1.4, 0.6, // identical angle to the base
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Cosine_Class",
+		Properties: map[string]interface{}{
+			"name": "object_3",
+		},
+		Vector: []float32{
+			-0.7, -0.3, // perfect opposite of the base
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Cosine_Class",
+		Properties: map[string]interface{}{
+			"name": "object_4",
+		},
+		Vector: []float32{
+			1, 1, // somewhere in between
+		},
+	})
+}
+
+func testCosine(t *testing.T) {
+	t.Run("without any limiting parameters", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	Get{
+			Cosine_Class(nearVector:{vector: [0.7, 0.3]}){
+		  	name
+		  	_additional{distance certainty}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Cosine_Class").AsSlice()
+		expectedDistances := []float32{
+			0,      // the same vector as the query
+			0,      // the same angle as the query vector,
+			0.0715, // the vector in between,
+			2,      // the perfect opposite vector,
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("limiting by certainty", func(t *testing.T) {
+		// cosine is a special case. It still supports certainty for legacy
+		// reasons. All other distances do not work with certainty.
+
+		t.Run("Get: with certainty=0 meaning 'match anything'", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], certainty: 0}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+				2,      // the perfect opposite vector,
+			}
+
+			compareDistances(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1,    // the same vector as the query
+				1,    // the same angle as the query vector,
+				0.96, // the vector in between,
+				0,    // the perfect opposite vector,
+			}
+
+			compareCertainties(t, expectedCertainties, results)
+		})
+
+		t.Run("Explore: with certainty=0 meaning 'match anything'", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], certainty: 0}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+				2,      // the perfect opposite vector,
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1,    // the same vector as the query
+				1,    // the same angle as the query vector,
+				0.96, // the vector in between,
+				0,    // the perfect opposite vector,
+			}
+
+			compareCertaintiesExplore(t, expectedCertainties, results)
+		})
+
+		t.Run("Get: with certainty=0.95", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], certainty: 0.95}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+			}
+
+			compareDistances(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1,    // the same vector as the query
+				1,    // the same angle as the query vector,
+				0.96, // the vector in between,
+				// the last element does not have the required certainty (0<0.95)
+			}
+
+			compareCertainties(t, expectedCertainties, results)
+		})
+
+		t.Run("Explore: with certainty=0.95", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], certainty: 0.95}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1,    // the same vector as the query
+				1,    // the same angle as the query vector,
+				0.96, // the vector in between,
+				// the last element does not have the required certainty (0<0.95)
+			}
+
+			compareCertaintiesExplore(t, expectedCertainties, results)
+		})
+
+		t.Run("Get: with certainty=0.97", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], certainty: 0.97}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+			}
+
+			compareDistances(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1, // the same vector as the query
+				1, // the same angle as the query vector,
+				// the last two elements would have certainty of 0.96 and 0, so they won't match
+			}
+
+			compareCertainties(t, expectedCertainties, results)
+		})
+
+		t.Run("Explore: with certainty=0.97", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], certainty: 0.97}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1, // the same vector as the query
+				1, // the same angle as the query vector,
+				// the last two elements would have certainty of 0.96 and 0, so they won't match
+			}
+
+			compareCertaintiesExplore(t, expectedCertainties, results)
+		})
+
+		t.Run("Get: with certainty=1", func(t *testing.T) {
+			// only perfect matches should be included now (certainty=1, distance=0)
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], certainty: 1}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+			}
+
+			compareDistances(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1, // the same vector as the query
+				1, // the same angle as the query vector,
+				// the last two elements would have certainty of 0.96 and 0, so they won't match
+			}
+
+			compareCertainties(t, expectedCertainties, results)
+		})
+
+		t.Run("Explore: with certainty=1", func(t *testing.T) {
+			// only perfect matches should be included now (certainty=1, distance=0)
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], certainty: 1}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+
+			expectedCertainties := []float32{
+				1, // the same vector as the query
+				1, // the same angle as the query vector,
+				// the last two elements would have certainty of 0.96 and 0, so they won't match
+			}
+
+			compareCertaintiesExplore(t, expectedCertainties, results)
+		})
+	})
+
+	t.Run("limiting by distance", func(t *testing.T) {
+		t.Run("Get: with distance=2, i.e. max distance, should match all", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], distance: 2}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+				2,      // the perfect opposite vector,
+			}
+
+			compareDistances(t, expectedDistances, results)
+		})
+
+		t.Run("Explore: with distance=2, i.e. max distance, should match all", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], distance: 2}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+				2,      // the perfect opposite vector,
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+		})
+
+		t.Run("Get: with distance=1.99, should exclude the last", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], distance: 1.99}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+				// the vector with the perfect opposite has a distance of 2.00 which is > 1.99
+			}
+
+			compareDistances(t, expectedDistances, results)
+		})
+
+		t.Run("Explore: with distance=1.99, should exclude the last", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], distance: 1.99}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between,
+				// the vector with the perfect opposite has a distance of 2.00 which is > 1.99
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+		})
+
+		t.Run("Get: with distance=0.08, it should barely still match element 3", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], distance: 0.08}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between, just within the allowed range
+				// the vector with the perfect opposite has a distance of 2.00 which is > 0.08
+			}
+
+			compareDistances(t, expectedDistances, results)
+		})
+
+		t.Run("Explore: with distance=0.08, it should barely still match element 3", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], distance: 0.08}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0,      // the same vector as the query
+				0,      // the same angle as the query vector,
+				0.0715, // the vector in between, just within the allowed range
+				// the vector with the perfect opposite has a distance of 2.00 which is > 0.08
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+		})
+
+		t.Run("Get: with distance=0.01, most vectors are excluded", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], distance: 0.01}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+				// the third vector would have had a distance of 0.07... which is more than 0.01
+				// the vector with the perfect opposite has a distance of 2.00 which is > 0.08
+			}
+
+			compareDistances(t, expectedDistances, results)
+		})
+
+		t.Run("Explore: with distance=0.01, most vectors are excluded", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], distance: 0.01}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+				// the third vector would have had a distance of 0.07... which is more than 0.01
+				// the vector with the perfect opposite has a distance of 2.00 which is > 0.08
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+		})
+
+		t.Run("Get: with distance=0, only perfect matches are allowed", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Get{
+					Cosine_Class(nearVector:{vector: [0.7, 0.3], distance: 0}){
+						name
+						_additional{distance certainty}
+					}
+				}
+			}
+			`)
+			results := res.Get("Get", "Cosine_Class").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+				// only the first two vectors are perfect matches
+			}
+
+			compareDistances(t, expectedDistances, results)
+		})
+
+		t.Run("Explore: with distance=0, only perfect matches are allowed", func(t *testing.T) {
+			res := AssertGraphQL(t, nil, `
+			{
+				Explore(nearVector:{vector: [0.7, 0.3], distance: 0}){
+					distance certainty
+				}
+			}
+			`)
+			results := res.Get("Explore").AsSlice()
+			expectedDistances := []float32{
+				0, // the same vector as the query
+				0, // the same angle as the query vector,
+				// only the first two vectors are perfect matches
+			}
+
+			compareDistancesExplore(t, expectedDistances, results)
+		})
+	})
+}
+
+func compareDistances(t *testing.T, expectedDistances []float32, results []interface{}) {
+	require.Equal(t, len(expectedDistances), len(results))
+	for i, expected := range expectedDistances {
+		actual, err := results[i].(map[string]interface{})["_additional"].(map[string]interface{})["distance"].(json.Number).Float64()
+		require.Nil(t, err)
+		assert.InDelta(t, expected, actual, 0.01)
+	}
+}
+
+func compareDistancesExplore(t *testing.T, expectedDistances []float32, results []interface{}) {
+	require.Equal(t, len(expectedDistances), len(results))
+	for i, expected := range expectedDistances {
+		actual, err := results[i].(map[string]interface{})["distance"].(json.Number).Float64()
+		require.Nil(t, err)
+		assert.InDelta(t, expected, actual, 0.01)
+	}
+}
+
+// unique to cosine for legacy reasons
+func compareCertainties(t *testing.T, expectedDistances []float32, results []interface{}) {
+	require.Equal(t, len(expectedDistances), len(results))
+	for i, expected := range expectedDistances {
+		actual, err := results[i].(map[string]interface{})["_additional"].(map[string]interface{})["certainty"].(json.Number).Float64()
+		require.Nil(t, err)
+		assert.InDelta(t, expected, actual, 0.01)
+	}
+}
+
+// unique to cosine for legacy reasons
+func compareCertaintiesExplore(t *testing.T, expectedDistances []float32, results []interface{}) {
+	require.Equal(t, len(expectedDistances), len(results))
+	for i, expected := range expectedDistances {
+		actual, err := results[i].(map[string]interface{})["certainty"].(json.Number).Float64()
+		require.Nil(t, err)
+		assert.InDelta(t, expected, actual, 0.01)
+	}
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/data_test.go

@@ -0,0 +1,98 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func addTestSchemaCosine(t *testing.T) {
+	createObjectClass(t, &models.Class{
+		Class:      "Cosine_Class",
+		Vectorizer: "none",
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+		VectorIndexConfig: map[string]interface{}{
+			"distance": "cosine",
+		},
+	})
+}
+
+func addTestSchemaOther(t *testing.T) {
+	createObjectClass(t, &models.Class{
+		Class:      "Dot_Class",
+		Vectorizer: "none",
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+		VectorIndexConfig: map[string]interface{}{
+			"distance": "dot",
+		},
+	})
+
+	createObjectClass(t, &models.Class{
+		Class:      "L2Squared_Class",
+		Vectorizer: "none",
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+		VectorIndexConfig: map[string]interface{}{
+			"distance": "l2-squared",
+		},
+	})
+
+	createObjectClass(t, &models.Class{
+		Class:      "Manhattan_Class",
+		Vectorizer: "none",
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+		VectorIndexConfig: map[string]interface{}{
+			"distance": "manhattan",
+		},
+	})
+
+	createObjectClass(t, &models.Class{
+		Class:      "Hamming_Class",
+		Vectorizer: "none",
+		Properties: []*models.Property{
+			{
+				Name:         "name",
+				DataType:     schema.DataTypeText.PropString(),
+				Tokenization: models.PropertyTokenizationWhitespace,
+			},
+		},
+		VectorIndexConfig: map[string]interface{}{
+			"distance": "hamming",
+		},
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/dot_test.go

@@ -0,0 +1,217 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func addTestDataDot(t *testing.T) {
+	createObject(t, &models.Object{
+		Class: "Dot_Class",
+		Properties: map[string]interface{}{
+			"name": "object_1",
+		},
+		Vector: []float32{
+			3, 4, 5, // our base object
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Dot_Class",
+		Properties: map[string]interface{}{
+			"name": "object_2",
+		},
+		Vector: []float32{
+			1, 1, 1, // a length-one vector
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Dot_Class",
+		Properties: map[string]interface{}{
+			"name": "object_3",
+		},
+		Vector: []float32{
+			0, 0, 0, // a zero vecto
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Dot_Class",
+		Properties: map[string]interface{}{
+			"name": "object_2",
+		},
+		Vector: []float32{
+			-3, -4, -5, // negative of the base vector
+		},
+	})
+}
+
+func testDot(t *testing.T) {
+	t.Run("without any limiting distance", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	 Get{
+			Dot_Class(nearVector:{vector: [3,4,5]}){
+		  	name
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Dot_Class").AsSlice()
+		expectedDistances := []float32{
+			-50, // the same vector as the query
+			-12, // the same angle as the query vector,
+			0,   // the vector in between,
+			50,  // the negative of the query vec
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a specified certainty arg - should error", func(t *testing.T) {
+		ErrorGraphQL(t, nil, `
+	{
+	  Get{
+			Dot_Class(nearVector:{certainty: 0.7, vector: [3,4,5]}){
+		  	name 
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+	})
+
+	t.Run("with a specified certainty prop - should error", func(t *testing.T) {
+		ErrorGraphQL(t, nil, `
+	{
+	  Get{
+			Dot_Class(nearVector:{distance: 0.7, vector: [3,4,5]}){
+		  	name 
+		  	_additional{certainty}
+		  }
+		}
+	}
+	`)
+	})
+
+	t.Run("with a max distancer higher than all results, should contain all elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	 Get{
+			Dot_Class(nearVector:{distance: 50, vector: [3,4,5]}){
+		  	name
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Dot_Class").AsSlice()
+		expectedDistances := []float32{
+			-50, // the same vector as the query
+			-12, // the same angle as the query vector,
+			0,   // the vector in between,
+			50,  // the negative of the query vec
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a positive max distance that does not match all results, should contain 3 elems", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	 Get{
+			Dot_Class(nearVector:{distance: 30, vector: [3,4,5]}){
+		  	name
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Dot_Class").AsSlice()
+		expectedDistances := []float32{
+			-50, // the same vector as the query
+			-12, // the same angle as the query vector,
+			0,   // the vector in between,
+			// the last one is not contained as it would have a distance of 50, which is > 30
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with distance 0, should contain 3 elems", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	 Get{
+			Dot_Class(nearVector:{distance: 0, vector: [3,4,5]}){
+		  	name
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Dot_Class").AsSlice()
+		expectedDistances := []float32{
+			-50, // the same vector as the query
+			-12, // the same angle as the query vector,
+			0,   // the vector in between,
+			// the last one is not contained as it would have a distance of 50, which is > 0
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a negative distance that should only leave the first element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	  Get{
+			Dot_Class(nearVector:{distance: -40, vector: [3,4,5]}){
+		  	name 
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Dot_Class").AsSlice()
+		expectedDistances := []float32{
+			-50, // the same vector as the query
+			// the second element's distance would be -12 which is > -40
+			// the third element's distance would be 0 which is > -40
+			// the last one is not contained as it would have a distance of 50, which is > 0
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a distance so small that no element should be left", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+	{
+	 Get{
+			Dot_Class(nearVector:{distance: -60, vector: [3,4,5]}){
+		  	name
+		  	_additional{distance}
+		  }
+		}
+	}
+	`)
+		results := res.Get("Get", "Dot_Class").AsSlice()
+		expectedDistances := []float32{
+			// all elements have a distance > -60, so nothing matches
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/explore_test.go

@@ -0,0 +1,128 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func testExplore(t *testing.T) {
+	className := "L2Squared_Class_2"
+	defer deleteObjectClass(t, className)
+
+	t.Run("create second L2 class", func(t *testing.T) {
+		createObjectClass(t, &models.Class{
+			Class:      className,
+			Vectorizer: "none",
+			Properties: []*models.Property{
+				{
+					Name:         "name",
+					DataType:     schema.DataTypeText.PropString(),
+					Tokenization: models.PropertyTokenizationWhitespace,
+				},
+			},
+			VectorIndexConfig: map[string]interface{}{
+				"distance": "l2-squared",
+			},
+		})
+	})
+
+	t.Run("create objects for the new class", func(t *testing.T) {
+		createObject(t, &models.Object{
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": "object_1",
+			},
+			Vector: []float32{
+				6, 7, 8,
+			},
+		})
+
+		createObject(t, &models.Object{
+			Class: className,
+			Properties: map[string]interface{}{
+				"name": "object_2",
+			},
+			Vector: []float32{
+				1, 2, 3,
+			},
+		})
+	})
+
+	t.Run("run Explore and assert results", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Explore(nearVector: {vector: [3, 4, 5], distance: 365}) {
+				distance
+				className
+			}
+		}
+		`)
+
+		explore := res.Get("Explore").AsSlice()
+
+		expected := []struct {
+			className string
+			dist      json.Number
+		}{
+			{className: "L2Squared_Class_2", dist: "12"},
+			{className: "L2Squared_Class_2", dist: "27"},
+			{className: "L2Squared_Class", dist: "50"},
+			{className: "L2Squared_Class", dist: "147"},
+			{className: "L2Squared_Class", dist: "365"},
+		}
+
+		for i, item := range explore {
+			m, ok := item.(map[string]interface{})
+			assert.True(t, ok)
+			assert.Equal(t, expected[i].dist, m["distance"])
+			assert.Equal(t, expected[i].className, m["className"])
+		}
+	})
+
+	t.Run("run Explore with certainty arg and expect failure", func(t *testing.T) {
+		res := ErrorGraphQL(t, nil, `
+		{
+			Explore(nearVector: {vector: [3, 4, 5], certainty: 0.4}) {
+				distance
+				className
+			}
+		}
+		`)
+
+		assert.Len(t, res, 1)
+		expectedErr := "can't compute and return certainty when vector index is configured with l2-squared distance"
+		errorMsg := res[0].Message
+		assert.Equal(t, expectedErr, errorMsg)
+	})
+
+	t.Run("run Explore with certainty prop and expect failure", func(t *testing.T) {
+		res := ErrorGraphQL(t, nil, `
+		{
+			Explore(nearVector: {vector: [3, 4, 5], distance: 0.4}) {
+				certainty
+				className
+			}
+		}
+		`)
+
+		assert.Len(t, res, 1)
+		expectedErr := "can't compute and return certainty when vector index is configured with l2-squared distance"
+		errorMsg := res[0].Message
+		assert.Equal(t, expectedErr, errorMsg)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/graphql_helper_test.go

@@ -0,0 +1,107 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/go-openapi/runtime"
+
+	"github.com/weaviate/weaviate/client/graphql"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+type GraphQLResult struct {
+	Result interface{}
+}
+
+// Perform a GraphQL request
+func QueryGraphQL(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, operation string, query string, variables map[string]interface{}) (*models.GraphQLResponse, error) {
+	var vars interface{} = variables
+	params := graphql.NewGraphqlPostParams().WithBody(&models.GraphQLQuery{OperationName: operation, Query: query, Variables: vars})
+	response, err := helper.Client(t).Graphql.GraphqlPost(params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return response.Payload, nil
+}
+
+// Perform a GraphQL request and call fatal on failure
+func QueryGraphQLOrFatal(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, operation string, query string, variables map[string]interface{}) *models.GraphQLResponse {
+	response, err := QueryGraphQL(t, auth, operation, query, variables)
+	if err != nil {
+		var parsedErr *graphql.GraphqlPostUnprocessableEntity
+		if !errors.As(err, &parsedErr) {
+			t.Fatalf("Expected the query to succeed, but failed due to: %#v", err)
+		}
+		t.Fatalf("Expected the query to succeed, but failed with unprocessable entity: %v", parsedErr.Payload.Error[0])
+	}
+	return response
+}
+
+// Perform a query and assert that it is successful
+func AssertGraphQL(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, query string) *GraphQLResult {
+	response := QueryGraphQLOrFatal(t, auth, "", query, nil)
+
+	if len(response.Errors) != 0 {
+		j, _ := json.Marshal(response.Errors)
+		t.Fatal("GraphQL resolved to an error:", string(j))
+	}
+
+	data := make(map[string]interface{})
+
+	// get rid of models.JSONData
+	for key, value := range response.Data {
+		data[key] = value
+	}
+
+	return &GraphQLResult{Result: data}
+}
+
+// Perform a query and assert that it has errors
+func ErrorGraphQL(t *testing.T, auth runtime.ClientAuthInfoWriterFunc, query string) []*models.GraphQLError {
+	response := QueryGraphQLOrFatal(t, auth, "", query, nil)
+
+	if len(response.Errors) == 0 {
+		j, _ := json.Marshal(response.Errors)
+		t.Fatal("GraphQL resolved to data:", string(j))
+	}
+
+	return response.Errors
+}
+
+// Drill down in the result
+func (g GraphQLResult) Get(paths ...string) *GraphQLResult {
+	current := g.Result
+	for _, path := range paths {
+		var ok bool
+		currentAsMap := (current.(map[string]interface{}))
+		current, ok = currentAsMap[path]
+		if !ok {
+			panic(fmt.Sprintf("Cannot get element %s in %#v; result: %#v", path, paths, g.Result))
+		}
+	}
+
+	return &GraphQLResult{
+		Result: current,
+	}
+}
+
+// Cast the result to a slice
+func (g *GraphQLResult) AsSlice() []interface{} {
+	return g.Result.([]interface{})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/hamming_test.go

@@ -0,0 +1,185 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func addTestDataHamming(t *testing.T) {
+	createObject(t, &models.Object{
+		Class: "Hamming_Class",
+		Properties: map[string]interface{}{
+			"name": "object_1",
+		},
+		Vector: []float32{
+			10, 10, 10,
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Hamming_Class",
+		Properties: map[string]interface{}{
+			"name": "object_2",
+		},
+		Vector: []float32{
+			10, 10, 12,
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Hamming_Class",
+		Properties: map[string]interface{}{
+			"name": "object_3",
+		},
+		Vector: []float32{
+			10, 11, 12,
+		},
+	})
+}
+
+func testHamming(t *testing.T) {
+	t.Run("without any limiting parameters", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,10,10]}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Hamming_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			1, // hamming distance to object_3 vector
+			2, // hamming distance to object_4 vector
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a certainty arg", func(t *testing.T) {
+		// not supported for non-cosine distances
+		ErrorGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,11,12], certainty:0.3}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+	})
+
+	t.Run("with a certainty prop", func(t *testing.T) {
+		// not supported for non-cosine distances
+		ErrorGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,11,12], distance:0.3}){
+					name 
+					_additional{certainty}
+				}
+			}
+		}
+		`)
+	})
+
+	t.Run("a high distance that includes all elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,10,10], distance: 365}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Hamming_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			1, // hamming distance to object_3 vector
+			2, // hamming distance to object_4 vector
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance that is too low for the last element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,10,10], distance: 1.5}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Hamming_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			1, // hamming distance to object_3 vector
+			// hamming distance to object_4 vector skipped because 2>1
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance that is too low for the second element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,10,10], distance: 0.5}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Hamming_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// hamming distance to object_3 vector skipped because 1>0.5
+			// hamming distance to object_4 vector skipped because 2>0.5
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance of 0 only matches exact elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Hamming_Class(nearVector:{vector: [10,10,10], distance: 0}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Hamming_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 1 > 0
+			// last eleme skipped, because 2 > 0
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/l2_test.go

@@ -0,0 +1,206 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func addTestDataL2(t *testing.T) {
+	createObject(t, &models.Object{
+		Class: "L2Squared_Class",
+		Properties: map[string]interface{}{
+			"name": "object_1",
+		},
+		Vector: []float32{
+			10, 11, 12,
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "L2Squared_Class",
+		Properties: map[string]interface{}{
+			"name": "object_2",
+		},
+		Vector: []float32{
+			13, 15, 17,
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "L2Squared_Class",
+		Properties: map[string]interface{}{
+			"name": "object_3",
+		},
+		Vector: []float32{
+			0, 0, 0, // a zero vecto
+		},
+	})
+}
+
+func testL2(t *testing.T) {
+	t.Run("without any limiting parameters", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12]}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "L2Squared_Class").AsSlice()
+		expectedDistances := []float32{
+			0,   // the same vector as the query
+			50,  // distance to the second vector
+			365, // l2 squared distance to the root
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a certainty arg", func(t *testing.T) {
+		// not supported for non-cosine distances
+		ErrorGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], certainty:0.3}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+	})
+
+	t.Run("with a certainty prop", func(t *testing.T) {
+		// not supported for non-cosine distances
+		ErrorGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], distance:0.3}){
+					name 
+					_additional{certainty}
+				}
+			}
+		}
+		`)
+	})
+
+	t.Run("a high distance that includes all elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], distance: 365}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "L2Squared_Class").AsSlice()
+		expectedDistances := []float32{
+			0,   // the same vector as the query
+			50,  // distance to the second vector
+			365, // l2 squared distance to the root
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance that is too low for the last element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], distance: 364}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "L2Squared_Class").AsSlice()
+		expectedDistances := []float32{
+			0,  // the same vector as the query
+			50, // distance to the second vector
+			// last eleme skipped, because 365 > 364
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance that is too low for the second element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], distance: 49}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "L2Squared_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 50 > 49
+			// last eleme skipped, because 365 > 364
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a really low distance that only matches one elem", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], distance: 0.001}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "L2Squared_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 50 > 0.001
+			// last eleme skipped, because 365 > 0.001
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance of 0 only matches exact elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				L2Squared_Class(nearVector:{vector: [10,11,12], distance: 0}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "L2Squared_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 50 > 0
+			// last eleme skipped, because 365 > 0
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/manhattan_test.go

@@ -0,0 +1,206 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func addTestDataManhattan(t *testing.T) {
+	createObject(t, &models.Object{
+		Class: "Manhattan_Class",
+		Properties: map[string]interface{}{
+			"name": "object_1",
+		},
+		Vector: []float32{
+			10, 11, 12,
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Manhattan_Class",
+		Properties: map[string]interface{}{
+			"name": "object_2",
+		},
+		Vector: []float32{
+			13, 15, 17,
+		},
+	})
+
+	createObject(t, &models.Object{
+		Class: "Manhattan_Class",
+		Properties: map[string]interface{}{
+			"name": "object_3",
+		},
+		Vector: []float32{
+			0, 0, 0, // a zero vector
+		},
+	})
+}
+
+func testManhattan(t *testing.T) {
+	t.Run("without any limiting parameters", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12]}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Manhattan_Class").AsSlice()
+		expectedDistances := []float32{
+			0,  // the same vector as the query
+			12, // distance to the second vector -> abs(10-13)+abs(11-15)+abs(12-17) = 3+4+5 = 12
+			33, // manhattan distance to the root -> 10+11+12 = 33
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("with a certainty arg", func(t *testing.T) {
+		// not supported for non-cosine distances
+		ErrorGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], certainty:0.3}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+	})
+
+	t.Run("with a certainty prop", func(t *testing.T) {
+		// not supported for non-cosine distances
+		ErrorGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], distance:0.3}){
+					name 
+					_additional{certainty}
+				}
+			}
+		}
+		`)
+	})
+
+	t.Run("a high distance that includes all elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], distance: 365}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Manhattan_Class").AsSlice()
+		expectedDistances := []float32{
+			0,  // the same vector as the query
+			12, // distance to the second vector -> abs(10-13)+abs(11-15)+abs(12-17) = 3+4+5 = 12
+			33, // manhattan distance to the root -> 10+11+12 = 33
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance that is too low for the last element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], distance: 30}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Manhattan_Class").AsSlice()
+		expectedDistances := []float32{
+			0,  // the same vector as the query
+			12, // distance to the second vector -> abs(10-13)+abs(11-15)+abs(12-17) = 3+4+5 = 12
+			// last skipped, as 33 > 30
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance that is too low for the second element", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], distance: 10}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Manhattan_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 12 > 10
+			// last eleme skipped, because 33 > 10
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a really low distance that only matches one elem", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], distance: 0.001}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Manhattan_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 12 > 0.001
+			// last eleme skipped, because 33 > 0.001
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+
+	t.Run("a distance of 0 only matches exact elements", func(t *testing.T) {
+		res := AssertGraphQL(t, nil, `
+		{
+			Get{
+				Manhattan_Class(nearVector:{vector: [10,11,12], distance: 0}){
+					name 
+					_additional{distance}
+				}
+			}
+		}
+		`)
+		results := res.Get("Get", "Manhattan_Class").AsSlice()
+		expectedDistances := []float32{
+			0, // the same vector as the query
+			// second elem skipped, because 12 > 0
+			// last eleme skipped, because 33 > 0
+		}
+
+		compareDistances(t, expectedDistances, results)
+	})
+}

platform/dbops/binaries/weaviate-src/test/acceptance/vector_distances/setup_test.go

@@ -0,0 +1,72 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package test
+
+import (
+	"testing"
+
+	"github.com/weaviate/weaviate/client/objects"
+	"github.com/weaviate/weaviate/client/schema"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/test/helper"
+)
+
+func Test_GraphQL(t *testing.T) {
+	t.Run("setup test schema (cosine only)", addTestSchemaCosine)
+	// at this point only cosine is present, so we can evaluate both Get and
+	// Explore
+	t.Run("import cosine test data ", addTestDataCosine)
+	t.Run("test cosine distance", testCosine)
+
+	// import rest of the schema meaning, we can only test Get, Explore is now
+	// impossible
+	t.Run("setup test schema (all)", addTestSchemaOther)
+	t.Run("import dot test data ", addTestDataDot)
+	t.Run("test dot distance", testDot)
+	t.Run("import l2 test data ", addTestDataL2)
+	t.Run("test l2 distance", testL2)
+	t.Run("import manhattan test data", addTestDataManhattan)
+	t.Run("test manhattan distance", testManhattan)
+	t.Run("import hamming test data", addTestDataHamming)
+	t.Run("test hamming distance", testHamming)
+
+	// tear down what we no longer need
+	deleteObjectClass(t, "Cosine_Class")
+	deleteObjectClass(t, "Dot_Class")
+	deleteObjectClass(t, "Manhattan_Class")
+	deleteObjectClass(t, "Hamming_Class")
+	deleteObjectClass(t, "C1")
+
+	// now only l2 is left so we can test explore with L2
+	t.Run("explore across multiple non-cosine classes", testExplore)
+
+	// tear down remaining classes
+	deleteObjectClass(t, "L2Squared_Class")
+}
+
+func createObjectClass(t *testing.T, class *models.Class) {
+	params := schema.NewSchemaObjectsCreateParams().WithObjectClass(class)
+	resp, err := helper.Client(t).Schema.SchemaObjectsCreate(params, nil)
+	helper.AssertRequestOk(t, resp, err, nil)
+}
+
+func createObject(t *testing.T, object *models.Object) {
+	params := objects.NewObjectsCreateParams().WithBody(object)
+	resp, err := helper.Client(t).Objects.ObjectsCreate(params, nil)
+	helper.AssertRequestOk(t, resp, err, nil)
+}
+
+func deleteObjectClass(t *testing.T, class string) {
+	delParams := schema.NewSchemaObjectsDeleteParams().WithClassName(class)
+	delRes, err := helper.Client(t).Schema.SchemaObjectsDelete(delParams, nil)
+	helper.AssertRequestOk(t, delRes, err, nil)
+}