# Vald: Kubernetes Architecture for Distributed Vector Search

> Vald is a Go-based approximate nearest neighbor search engine designed for Kubernetes clusters and distributed indexing. It fits large vector workloads, but requires Kubernetes, AVX2-capable infrastructure, and operation of several service components.

**vdaas/vald** — Vald.  A Highly Scalable Distributed Vector Search Engine

- Repository: https://github.com/vdaas/vald
- Website: https://vald.vdaas.org
- Stars: 1,736 · Forks: 93
- Language: Go
- License: Apache-2.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/vdaas-vald

## Vald's target workload: large-scale approximate vector retrieval

Vald addresses approximate nearest neighbor search over dense vector data. Applications convert objects such as images, audio, video, text, or binary data into vectors, send those vectors to Vald, and use search results for recognition, recommendation, detection, grammar checking, or translation workflows. The important word is approximate. Vald is intended to retrieve nearby vectors without performing an exhaustive comparison against every stored vector, making it suitable for large similarity-search datasets where exact search would become too expensive.

The intended users are engineers operating cloud-native search infrastructure rather than developers wanting a small Go library. The repository describes horizontal scaling, automatic vector indexing, and index backup. Those capabilities place Vald closer to a distributed database service than a local vector-search package. Its stated purpose is searching billions of feature vectors, although the README does not provide a reproducible capacity result or claim a fixed billion-vector limit for a particular configuration.

That distinction matters during adoption. A small recommendation feature, prototype, or internal tool may not justify running discovery, gateway, indexing, and storage components across a Kubernetes cluster. Vald becomes more defensible when vector traffic is already distributed, the dataset is large enough to require horizontal operation, and the team can manage Kubernetes services and persistent indexes.

## NGT agents and service discovery inside Vald

Vald uses NGT as its ANN search algorithm. The repository identifies the Vald Agent NGT component as the part that requires AVX2 instructions, so vector-search capability is tied to compatible compute infrastructure rather than being independent of the host CPU. The README also lists Agent Sidecar, Discoverer, and Gateway roles. Based on those component names and the architecture description, Vald separates search execution, Kubernetes service discovery, and client-facing traffic instead of placing every operation in one process.

The service split supports horizontal operation. Agent NGT instances can execute index work and searches, while the Discoverer maintains awareness of Kubernetes services and gateways provide the external entry path. The README explicitly claims automatic vector indexing and index backup, and the component table includes separate image definitions for Agent NGT and Agent Sidecar. The README does not explain the internal RPC sequence for inserting a vector, assigning it to an agent, or routing a search, so those protocol details should not be inferred.

The practical consequence is that Vald is a distributed system with several moving parts. Understanding `helm install` only creates the chart installation. Determining request routing, readiness behavior, index persistence, and failure handling requires the official Get Started tutorial and the repository documentation. Engineers evaluating the service should not equate a successful Helm command with a searchable production deployment.

## Installing Vald with the official Helm chart

The shortest installation path documented in the README uses the project's Helm repository. Run these commands in an environment that already has access to a Kubernetes cluster:

```bash
helm repo add vald https://vald.vdaas.org/charts
helm install vald-cluster vald/vald
```

The first command registers `https://vald.vdaas.org/charts` under the local repository name `vald`. The second creates a release named `vald-cluster` from the `vald/vald` chart. There is an important image-selection caveat: the README says the default `values.yaml` installs `nightly` images. Operators who require the published `latest` images must account for that distinction.

Before executing the commands, check the documented platform requirements. The README requires Kubernetes 1.19 or later and AVX2 instructions for Vald Agent NGT. After installation, the README directs users to the official Get Started page for the first real use:

```text
https://vald.vdaas.org/docs/tutorial/get-started
```

The README does not contain an insert-vector or search command, client request, configuration file, or readiness check. It would be misleading to present an invented `curl` invocation as Vald's supported first search. Follow that tutorial for the current client setup, then verify that the gateway route and NGT agent are ready before treating results as production input.

## Kubernetes and AVX2 as Vald's admission conditions

Vald's strongest constraint appears before feature evaluation. Kubernetes 1.19 or later is required, and the Vald Agent NGT requires AVX2. These conditions exclude many local development machines and managed environments whose worker CPU feature sets are not known or cannot be selected. They also make Kubernetes the deployment substrate rather than an optional convenience.

This architecture can fit an existing platform team, but it creates a different cost profile from an embedded library. The organization must provide cluster capacity, deploy multiple component images, observe service health, and account for persistent index storage. Horizontal scaling may be necessary for large datasets, yet the README does not specify resource requests, replica settings, storage classes, or autoscaling controls. Those values must be checked in the chart and tutorial rather than guessed.

AVX2 deserves particular attention during node preparation. A cluster can satisfy the documented Kubernetes version and still fail the agent's processor requirement if its workers lack the required instruction set. The README identifies the requirement but does not give a detection command or mixed-architecture deployment procedure. Infrastructure verification therefore has to precede an architectural pilot.

## Why Vald differs from an embedded ANN index

Vald is an alternative to running an ANN implementation inside one application process. An embedded index typically keeps vectors and graph data near the calling service and exposes direct library calls. Vald instead distributes ANN work across Kubernetes components and presents the repository as a service-oriented, horizontally scalable engine. That approach is materially different because capacity is added through infrastructure components rather than only through memory available to one process.

The alternative is most reasonable for a modest dataset, a single writer, or a deployment without Kubernetes. In that case, an embedded NGT-based implementation may reduce the number of moving services, although the README does not identify a particular Go package or client library for that purpose. The README does not supply a direct feature, performance, or operational comparison, so no superiority claim should be made from the documentation alone.

Vald earns consideration when independent service scaling, centralized vector retrieval, or index backup across distributed agents is part of the design. It is the wrong tool when the immediate requirement is a single binary calling a local index. The deciding factor is not language compatibility. Both the application and repository are associated with Go, but the operational model is what differs.

## Release cadence, upgrade work, and Apache-2.0 obligations

The repository is not archived, and the last push was on 2026-10-15. Recent releases include v1.8.1 on 2026-10-13, v1.8.0 on 2026-08-26, and v1.7.17 on 2025-07-04. Those dates show recent release work, but the README does not document a supported upgrade path, compatibility matrix, migration procedure, or rollback process. The repository includes `CHANGELOG.md`, and release-specific notes should be reviewed for each upgrade rather than assuming that a minor version can be applied without checking component and chart compatibility.

The project is licensed under Apache-2.0. That permits use and modification under the license's conditions, but this review does not interpret the legal obligations. Organizations should review the repository `LICENSE` file with their own policy, including any attribution, notice, redistribution, and patent-related requirements relevant to their distribution model.

The upgrade cost is likely tied to the distributed deployment. Because Vald is presented through Kubernetes services, an upgrade can involve chart changes and component image compatibility rather than a single replacement binary. The README does not quantify that effort or confirm which versions can be upgraded directly. The last release dates and repository activity are useful for assessing whether the project is moving, but they are not evidence that a particular upgrade is safe.

## Conclusion

Vald suits organizations that already operate Kubernetes, have AVX2-capable infrastructure, and need a distributed NGT-based ANN service. It is a poor fit for a small application that needs an embedded vector index without cluster operations. Before adoption, verify AVX2 availability, inspect the official Get Started tutorial for the current client workflow, and confirm that the multi-service deployment fits the workload's operational and hardware constraints.

## FAQ

### What is Vald used for?

Vald performs approximate nearest neighbor searches over dense vectors. It is intended for large similarity-search workloads involving converted image, audio, video, text, binary, or other object data.

### How do I install Vald with Helm?

The README registers the Vald Helm repository and installs the `vald/vald` chart as `vald-cluster`. With default `values.yaml`, the installation uses `nightly` images.

### What are Vald's Kubernetes and CPU requirements?

The README documents Kubernetes 1.19 or later. Vald Agent NGT also requires AVX2 instructions.

## Sources

- [License: Apache-2.0](https://github.com/vdaas/vald/blob/main/LICENSE)
- [Project website](https://vald.vdaas.org)
- [README](https://github.com/vdaas/vald/blob/main/README.md)
- [Releases](https://github.com/vdaas/vald/releases)
- [vdaas/vald on GitHub](https://github.com/vdaas/vald)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/vdaas-vald