For developers

Vela integrations

Plug Vela into your existing stack: official SDKs, embedding providers, data sources and observability tooling. The index stays queryable throughout the whole setup.

Principle

One API, four verbs

Vela exposes a single HTTP API: create an index, write vectors, query by similarity, delete. Everything else is a matter of connecting that API to your tools.

You produce the embeddings with whichever model you like. Vela indexes them, applies your metadata filters and returns the k nearest neighbours. The official SDKs handle pagination, retries and batching.

Python, TypeScript, Go and Rust SDKs

Works with any embedding provider

Reindexing without service interruption

Vela connection diagram

12 ms

p99 latency

99th-percentile response time for a k-NN query, metadata filters included.

1 B

Vectors per index

An index takes up to 1 billion vectors, sharded automatically.

99.2 %

Measured recall

Recall of the HNSW index compared to an exhaustive search over the same vector set.

4096

Maximum dimensions

Vectors can go up to 4096 dimensions, whatever the embedding model.

Setup

Four steps to connect

From the first API call to an observed production rollout, each step plugs in independently.

Step 1

Install an SDK

Install the official client in your language, declare an API key and create a first index, specifying the dimension and the similarity metric.

Python, TypeScript, Go and Rust SDKs
HTTP API for every other language
Cosine similarity or dot product
Namespaces to separate your data

~5 min to the first index

Step 2

Plug in an embedding model

Vela indexes the vectors you send it. The model stays your call: a hosted API or an open-source model running on your own infrastructure.

OpenAI, Cohere, Mistral
Self-hosted open-source models
Up to 4096 dimensions per vector
Multilingual embeddings across 40 languages

1 field to declare when creating the index

Step 3

Feed the index

Load the backlog from your storage systems, then keep the index current from a stream. Writes and queries coexist without locking.

Initial import from S3 or Postgres
Continuous updates via Kafka
Webhooks for single-record writes
Background reindexing

1 B vectors per index

Step 4

Query and observe

k-NN queries come from your application or from a RAG framework. Traces and metrics are exported to the tools you already use.

k-NN queries with metadata filters
RAG chains via LangChain or LlamaIndex
Traces in OpenTelemetry format
p50/p99 latency metrics to Datadog

12 ms measured p99 latency

Clients

The official SDKs

Four clients maintained by our team, with the same API surface and the same retry guarantees.

Python SDK

Sync and async clients, batch writes and direct integration with the RAG frameworks.

TypeScript SDK

Types generated from the API schema, compatible with Node.js and edge runtimes.

Go SDK

Connection pooling, cancellable contexts and OpenTelemetry instrumentation you can switch on.

Rust SDK

An allocation-light client for high-rate query paths.

Ecosystem

Integration families

Four categories of tooling connect to Vela, from computing embeddings through to monitoring.

Embedding providers

Vela accepts vectors produced by any model, hosted or running on your own machines.

OpenAI and Cohere
Mistral
Self-hosted open-source models

RAG frameworks

Vela works as the vector store in retrieval-augmented generation chains.

LangChain
LlamaIndex
Direct calls to the HTTP API

Data sources

Feed an index from your existing systems, first as a bulk import then as a continuous stream.

S3 and compatible storage
Postgres and Kafka
Inbound webhooks

Observability

Every query is traced: p50/p99 latency, estimated recall and vector count per shard.

OpenTelemetry
Datadog
Prometheus export

Operations

What the integration leaves in your hands

Once the connection is live, four levers remain yours to tune how the index behaves.

Metadata filters

Restrict a k-NN query by attribute, language or date without hurting latency.

Tuning the HNSW trade-off

Balance recall against p99 latency per index, without rebuilding the data.

Namespaces and API keys

Separate vector sets by environment or by tenant inside a single index.

Scheduled reindexing

Switch embedding model and rebuild the index while queries keep flowing.

Missing an integration?

Describe your stack to contact@vela.dev. The step-by-step guides live on docs.vela.dev.

Ready to plug Vela into your stack?

Create an index, send your first vectors and measure the latency from your own services.

Explore the product See the pricing