How much RAM does Weaviate need?

Weaviate itself uses 400–600 MB at idle. Total memory scales with your index: HNSW parameters, the number of objects and their vector dimension are the main factors. A 4 GB VPS comfortably handles collections of a few hundred thousand objects with 1536-dimensional vectors. Enable binary quantisation for large-scale deployments to cut memory by up to 32×.

Can I use Weaviate alongside Qdrant on the same VPS?

Yes. Weaviate listens on port 8080 (REST/GraphQL) and 50051 (gRPC), Qdrant on 6333 (REST) and 6334 (gRPC) — no port conflict. Both are single-container deployments. On a 4 GB VPS, running both at once is possible but tight; a 8 GB VPS gives comfortable headroom for both databases plus an LLM inference tool like Ollama.

Which frameworks integrate natively with Weaviate?

LangChain, LlamaIndex, Haystack and DSPy all ship a Weaviate vector store connector. The official client libraries cover Python, Go, TypeScript and Java. Any HTTP-capable tool can also use the REST or GraphQL API directly.

Build, host and run AI solutions.

Weaviate

Self-hosted multimodal vector database — GraphQL, RAG and built-in vectorizers on your VPS.

2 GB RAM 1 vCPU Port 8080 In validation

In validation

Automatic installation for this solution is ready and currently going through our tests on a real server. Ordering will open as soon as validation is complete.

Tech stack

DockerGo

Minimum RAM2 GB

Minimum CPU1 vCPU

Default port8080

Compatible OSChoice of Linux distributions

Weaviate is an open-source vector database written in Go, designed for semantic search and retrieval-augmented generation at scale. Unlike pure vector stores, Weaviate ships built-in vectorizer modules — text2vec-openai, text2vec-cohere, img2vec — that embed your data at ingest time without any client-side preprocessing. Data, vectors and structured metadata live together in the same record, so a single GraphQL or REST query returns semantically relevant objects with all their properties.

Deployed on a ServOrbit VPS, Weaviate becomes the memory and retrieval layer of your AI stack: feed it documents, images or knowledge-base entries and let your LLM (via LangChain, LlamaIndex or a direct API call) pull the most relevant context before generating a response. The loopback binding keeps all data on your machine — no embeddings or private content ever leave the server.

Key features

Built-in vectorizer modules — text2vec-openai, text2vec-cohere, img2vec — embed data at ingest, no client-side preprocessing

GraphQL and REST APIs — query by vector similarity, scalar filters or a combination in one request

Multi-modal collections — store text, images and structured metadata together in the same object

Native LangChain, LlamaIndex and Haystack integrations — drop-in replacement for managed vector stores

BSD-3-Clause licence — fully auditable, no telemetry, air-gap capable

Go runtime — low memory footprint, fast startup, deterministic GC pauses under load

When to use this solution?

1

RAG pipeline memory

Index your documentation or knowledge base in Weaviate using the text2vec module of your choice. At query time, retrieve the top-k most relevant chunks and pass them as context to your LLM. The entire pipeline runs on your VPS — no data leaves the machine.

2

Semantic search across documents

Replace keyword-based search with meaning-based retrieval. A query for 'invoice dispute resolution' surfaces results about 'billing conflict handling' even when those words never appear, because Weaviate compares intent encoded as vectors.

3

Multi-modal retrieval

Store product images alongside their descriptions and metadata in the same Weaviate collection. Search by image similarity, text description or a combination — useful for e-commerce catalogues, design asset libraries or document archives that mix text and visuals.

Deploy Weaviate on your VPS

Guide optimized for ServOrbit Cloud VPS.

01

Order a ServOrbit VPS

Plan for at least 2 GB of RAM: Weaviate itself idles around 400–600 MB, with additional memory for your index and any vectorizer modules you enable. A 4 GB VPS is a comfortable starting point. The machine ships with Ubuntu 24.04 and Docker pre-installed.

02

Deploy from the Marketplace

In your ServOrbit client area: Marketplace → Artificial Intelligence → Weaviate → Deploy. The semitechnologies/weaviate:1.27.2 image starts in seconds. The REST and GraphQL APIs answer on port 8080; the gRPC API listens on port 50051 — both restricted to 127.0.0.1. The weaviate_data volume keeps your schema and objects across container restarts.

03

Connect for the first time

This Weaviate instance runs with anonymous access enabled — no API key is required to connect. The ports are bound to 127.0.0.1 only, so the database is not reachable from the public internet. To call the REST or GraphQL API from your workstation, open an SSH tunnel: ssh -L 8080:127.0.0.1:<port> root@<vps-ip> (replace <port> with the port shown in your client area), then query http://localhost:8080/v1/schema.

04

Create a class and ingest your data

Define your schema with a single REST call: curl -X POST http://localhost:8080/v1/schema -H 'Content-Type: application/json' -d '{"class":"Document","vectorizer":"none","properties":[{"name":"content","dataType":["text"]}]}'. With vectorizer: none you supply your own embeddings on each import. Switch to text2vec-openai (and add OPENAI_APIKEY to the container env) to let Weaviate call the embedding model automatically at ingest time.

05

Query with GraphQL or REST

Run a nearest-neighbour search in GraphQL: curl http://localhost:8080/v1/graphql -d '{"query":"{Get{Document(nearVector:{vector:[0.1,0.2,...]},limit:5){content _additional{certainty}}}}"}' -H 'Content-Type: application/json'. For structured access, the REST /v1/objects and /v1/batch endpoints are available via the official Python, Go, TypeScript and Java clients.

06

Secure the instance

Enable API-key authentication by adding AUTHENTICATION_APIKEY_ENABLED=true and AUTHENTICATION_APIKEY_ALLOWED_KEYS=<your-key> to the container environment variables and restarting it. Once a key is set, every request must include the Authorization: Bearer <key> header. The instance can then be safely published behind a domain, with the nginx vhost and TLS certificate ServOrbit manages.

Frequently asked questions

Both are open-source vector databases, but their design philosophies differ. Qdrant (Rust) focuses on pure vector similarity search with payload filters — it is schema-free and brings no vectorization. Weaviate (Go) adds a schema layer and built-in vectorizer modules that call embedding models at ingest time, plus a GraphQL API and native multi-modal support. Choose Qdrant for raw performance on pre-embedded vectors; choose Weaviate when you want the database to handle embedding and you need GraphQL query syntax or multi-modal collections.

No. Setting DEFAULT_VECTORIZER_MODULE=none (the default in this deployment) means Weaviate never calls an external embedding API. You supply your own float vectors on every import. The text2vec-openai, text2vec-cohere and other cloud modules are optional — enable them only if you want Weaviate to call the embedding service automatically.

Complementary solutions

Artificial Intelligence

Weaviate isn't orderable yet.