How to use this self-hosted vector database requirements checklist
A team usually arrives here with documents or records that need embedding and search, and a shortlist of Qdrant, Milvus, Weaviate or pgvector. The most expensive mistake is choosing an engine before agreeing what the store must do. Use this checklist before any platform comparison or proof of concept. Each requirement should carry the name of one accountable owner, such as the security lead for authentication and RBAC, the data owner for retention and deletion, and the platform lead for backups, HA and scale. A requirement without an owner is an open question, and it should be treated as one.
The same list then drives the vendor-neutral RFP. Every candidate engine and every implementation partner answers the same questions about scale, dimensions, filtering, multi-tenancy, RBAC, restore rules and embedding pipeline integration, so answers can be compared directly. Open-source engines are free to self-host. Qdrant, for example, is licensed under Apache-2.0 and its open-source engine is free to self-host, so the license is rarely the deciding cost. Confirm the license terms of each engine and of any add-on, because some enterprise features sit behind separate licenses.
The real cost sits in infrastructure and people. Memory, storage, replicas, backup capacity and the staff who operate, patch and restore the cluster recur every month, while design, hardening and migration work is largely one-time. Ask any partner to price each requirement you sign off, including the operations effort for the failure cases you define, so the quote follows from the agreed scope rather than from the engine's list price.
Functional requirements to agree on scale, dimensions and search
This table compares the functional requirements that decide which vector store fits, covering scale, filtering, hybrid search, reranking, indexing and expiry. Each row explains why the requirement matters and how to verify it with a load test on your own vectors. Treat vendor capability claims as hypotheses until a test on your data confirms them.
| Requirement | Why it matters | How to verify |
|---|---|---|
| Vector count and growth rate | Memory and disk needs scale with the number of vectors, and growth determines when sharding and replication become necessary. Record both the current count and the expected count after 12 and 36 months. | Load a representative sample at projected size, measure memory and disk per million vectors, and extrapolate growth with your own ingestion rate. |
| Embedding dimensions and model changes | Dimension count sets per-vector storage and index memory. A change of embedding model usually means a new dimension count and full re-embedding of the corpus. | Confirm the dimensions your chosen model outputs, test the target engine at that size, and document the re-embedding procedure and its runtime. |
| Metadata filtering and predicates | Access checks, tenant isolation and date or document-type limits often run as filters during search. Filters that are slow or that reduce recall break both performance and access control. | Run filtered queries with selective predicates on your own metadata and compare results and latency against unfiltered queries. Confirm filter behavior with each vendor rather than assume it. |
| Hybrid BM25 and vector search | Exact terms such as product codes, policy numbers and names often fail under pure semantic search. Some engines combine keyword and vector scoring natively, others need an application layer. | Check whether the engine runs BM25 and dense search in one query. Milvus documents BM25, sparse vectors and hybrid dense plus sparse search, and Weaviate combines vector similarity with BM25 filtering in one interface. Test both against a labeled set of queries. |
| Reranking | A reranker re-scores the top candidates and often improves answer quality for retrieval-augmented generation, but it adds latency and a model to host. | Decide whether reranking runs inside the database, in the RAG application or as a separate service, then measure answer quality and added latency on your query set. |
| Index type and quantization | Index choice trades recall, memory and build time. Quantization reduces memory but can lower recall, so the setting must be tuned against your own data. | Compare recall at a fixed latency for each index and quantization setting on your vectors. Milvus documents HNSW, IVF, FLAT, SCANN and DiskANN indexes and quantization, and Weaviate lists quantization as a built-in feature. Confirm supported options for your version. |
| Object time-to-live and deletion | Derived vectors may need to expire with source records or retention schedules. Expiry that does not reach replicas and backups leaves stale data behind. | Set a test time-to-live, confirm removal from search results, and check whether deleted vectors persist in snapshots or backups. Weaviate lists per-collection object time-to-live as a built-in feature. Confirm the behavior for your version. |
Security requirements to write into the RFP
A vector store holds document-derived content that often mirrors confidential source records, so its security requirements should be written before a product is shortlisted. The cards below cover access control, transport, network exposure, logging and secrets, and each one asks the buyer to confirm the capability in the exact version they will run.
Default-deny network exposure
Self-deployed Qdrant instances listen on all network interfaces and ship with no authentication configured, so an unhardened install is reachable by anyone who can route to it. Write a default-deny network posture into the RFP: bind services only to the internal interfaces they need, restrict ingress to the application tier and admin hosts, and block the database ports from user networks. Ask the partner to show the firewall rules and the bind configuration in the delivered environment, not just the vendor's documentation.
Authentication before any collection
Qdrant supports admin and read-only API keys, Weaviate supports API key, OIDC and anonymous access, and Milvus documents authentication as a feature. Anonymous access is discouraged by Weaviate outside development, so the RFP should forbid it in production and require that the chosen method be enabled and tested before data is loaded. Ask which identity provider the store will federate with, how service accounts are created and rotated, and whether the vendor's version in use supports each method.
Per-collection and per-tenant permissions
Role-based access control is what keeps one application or user group from reading another's embeddings. Qdrant documents JWT-based granular access with per-collection read or write permissions, Weaviate assigns custom roles through its user management API, and Milvus offers role-based access control. Require that permissions can be scoped to a collection, and that write rights to the ingestion pipeline are separate from query rights for applications. Ask the partner to demonstrate a denied query in a test tenant before sign-off.
TLS for REST and gRPC
Embeddings and the query text that produces them can reveal sensitive content even though they are not readable documents, so traffic between applications, the ingestion pipeline and the store should be encrypted. Qdrant supports TLS for both REST and gRPC, Weaviate and Milvus document TLS as well. Write the requirement so that both protocols are covered, internal certificates come from the organization's own authority, and the RFP states which ports are plaintext if any remain during migration.
Audit logging of queries and changes
Auditors and, for high-risk AI systems, the EU AI Act's logging duties expect a record of who accessed what and when. Qdrant added JSON audit logging of authenticated API operations in v1.17.0, so confirm that version or a later one is in the scope and that logs ship to the organization's SIEM with retention set by policy. Ask whether query texts, deletions and permission changes are logged, and who can alter or disable the log configuration.
Secrets and key handling
API keys, OIDC client secrets, database credentials and TLS private keys are the usual route into a vector store, and they often end up in container environment files. Require that secrets be held in the organization's secrets manager or an approved vault, injected at runtime, rotated on a documented schedule and revoked when a team changes. Ask the partner which secrets the deployment creates, where each one is stored, and how the runbook proves that a retired key no longer works.
Multi-tenancy and isolation: which level of separation is required
Decide the isolation level before you create any collection, because it determines how hard it is to delete one tenant's data, how one tenant's load affects others, and where entitlement checks happen. The options run from a separate database or deployment per tenant, to a collection per tenant, to a shared collection with a partition or partition key per tenant, to a tenant attribute on each object filtered at query time. Milvus offers multi-tenancy at database, collection, partition or partition key level, and Weaviate provides its own multi-tenancy feature, so the choice is partly a product decision. Confirm the exact tenant mechanism, its limits and its behavior under your chosen version with the vendor before you commit to a data model.
Per-tenant deletion is the easiest test to run early. A dedicated collection or database can be dropped as one operation and its snapshots and backups can be scoped to it, while a tenant key inside a shared collection requires filtered deletes that must also be applied to every replica, snapshot and backup that still holds those vectors. Noisy neighbors are the mirror risk: shared collections share index memory, write-ahead log capacity and query threads, so one large tenant can slow search for the rest. Ask the vendor how resource limits, quotas or replica placement can be applied per tenant, and measure query latency with a realistic tenant size mix before going live. If you need a fixed proof of isolation for a regulator or customer, ask what evidence the platform itself can produce, not just what the design intends.
Entitlement-aware filtering is where isolation is most often left to application code. A tenant key or access list stored in the payload only protects data if every query path applies it, including reranking, hybrid search and admin tooling, and if the filter cannot be bypassed by a client that holds a broad API key. Pair the data model with per-collection permissions, such as the JWT-based access control Qdrant documents or the role-based access control Weaviate and Milvus describe, and test it with a negative case for each tenant. For depth on tenant-level design for software vendors, see the multi-tenant vector search for SaaS products page, and for supervised access and retention in banks and insurers, see the self-hosted vector database for financial services page.
Integration requirements for the embedding pipeline
Embeddings connect the vector store to every system around it, so the pipeline decisions shape the store as much as the engine does. Agree where vectors are generated, how each vector is traced to its model version, how documents arrive, and which clients and RAG frameworks will query the store. Treat re-embedding on model change as a funded requirement from day one.
Where vectors are generated
Decide whether the store vectorizes data at import through an integrated provider, or whether your own pipeline sends pre-computed embeddings. Weaviate can call providers such as OpenAI, Cohere or Hugging Face during import, which sends document text to that provider. Pre-computed vectors keep text and model calls inside your pipeline, where you control logging and egress. Confirm for each option which component sees raw document text and which network path it uses.
Embedding model version per vector
Store the embedding model name, version and dimension as metadata on every vector or in a companion record. Without this, a mixed index built from two models returns scores that look valid but mean nothing. Require that queries are embedded with the same model as the indexed content. Ask any partner how the model version is recorded, where it is queried, and how mismatches are blocked at write time.
Re-embedding on model change
Changing an embedding model means every vector must be regenerated, and the old and new vectors cannot be compared. Make re-embedding a documented requirement with a named owner, a method for building a new collection beside the old one, and a cutover that does not require downtime. Estimate the compute and time for a full re-embed before you commit to a model. Ask the partner to show this procedure in a test environment.
Ingestion from stores and orchestrators
Map every source system, such as document management, wiki, ticketing or file shares, to an ingestion job that chunks, embeds and writes points. Orchestrators such as Apache Airflow (version 3.3.2 in the supplied facts) and Dagster (1.13.26) can schedule and retry these jobs and expose failures. Require idempotent upserts keyed on source IDs, so reruns do not duplicate vectors. Confirm how deletions and permission changes in the source reach the index.
API and client language support
List the languages your teams and pipelines use before selecting an engine. Weaviate publishes official clients for Python, JavaScript/TypeScript, Java, Go and C#/.NET and exposes REST, gRPC and GraphQL APIs. Milvus and Qdrant also provide client libraries, but confirm the language coverage, version compatibility with your server release, and whether the client supports the authentication scheme you will enforce.
LLM application and RAG framework
Name the application or framework that will call the store, such as RAGFlow, AnythingLLM, Dify, Open WebUI or custom code. Each one has its own expectations for collection naming, metadata fields, filter syntax and hybrid query support. Confirm whether the framework writes to the store or only reads, which credentials it uses, and whether it can pass the user's identity so that permission filters apply at query time.
Operational requirements: backups, restore rules and HA
This table sets out the backup, restore, replication, storage, upgrade and monitoring requirements to agree before choosing a vector store, with a verification step for each. Read it as a checklist: if a requirement cannot be verified in a timed restore drill or a failover test, treat it as unproven. The main takeaway is that a backup schedule means little until a restore has been run into a separate environment and timed against an agreed target.
| Requirement | What to agree | How to verify |
|---|---|---|
| Backup method and schedule | Choose snapshots per collection or cluster-level backups, the schedule, retention periods and where copies are stored, kept inside the organization's own storage | Confirm the snapshot method in the chosen engine's documentation, then check that backup jobs run and produce restorable files on schedule |
| Restore testing frequency | Agree how often a restore runs and who signs off, with a documented acceptance criterion such as collection counts and sample query results matching the source | Run a timed restore drill into a separate environment and compare point counts and sample search results against production |
| Acceptance criteria for restore | Define the recovery time and recovery point the business accepts, and the search quality checks that must pass after restore | Record the measured restore duration and data gap from each drill and compare them with the agreed targets |
| Snapshot version matching | Restore only into the same engine version the snapshot was taken from, unless the vendor confirms a supported upgrade path | Check the engine version recorded with each snapshot before restore and document the version used in the drill |
| Replication factor and consistency level | Set the replication factor per collection. In Qdrant a factor of 2 doubles storage. Agree the read and write consistency level for each workload | Review the configured replication factor per collection and test that searches still answer after one node is stopped |
| Node count for quorum | Qdrant's distributed deployment docs recommend at least three nodes for production so quorum survives a node failure. Confirm the minimum for any other engine chosen | Stop one node in a staging cluster and confirm the cluster keeps serving reads and writes and recovers when the node returns |
| Storage type | Block-level storage with a POSIX-compatible file system, with SSD or NVMe recommended for Qdrant. Qdrant cannot run on NFS or S3-style object storage | Inspect the mount type on each node and reject any volume backed by a network file system or object storage before go-live |
| Upgrades | Agree a version pinning policy, a staging upgrade path, a rollback plan and whether a Helm chart or an enterprise operator will manage rolling changes | Upgrade a staging copy with production-like data, run the restore drill on the new version and record any failed queries |
| Monitoring and alerting | Define alerts for node health, disk and memory use, replication lag, failed backups and query latency, with named owners | Trigger a test alert from each rule and confirm it reaches the on-call channel, then keep the results as evidence |
Licence terms that change what you can build and sell
The licence question for a vector database is not only whether the engine is free to run. It is whether the features you need sit under the open licence, and whether you can offer the product to customers as a hosted service. Qdrant is licensed under Apache-2.0 and Milvus is Apache-2.0 licensed, so the core engines carry permissive terms. Weaviate's LICENSE file places code outside its wl directory under BSD-3-Clause, while code inside wl requires a separate Weaviate enterprise license, and enterprise features are enabled by a license key. Confirm, feature by feature, which capabilities on your list (for example RBAC, audit logging, multi-tenancy or SSO) are in the open code and which depend on a key or a paid tier.
Two questions decide most of the risk. The first is whether the platform will be used only inside your organization or offered to customers as a hosted or managed service, because some licences restrict that use even where the core code is permissive. The second is what the vendor's commercial terms cover, such as support, indemnities, feature entitlements, and what happens to a deployed key when a contract lapses. Write these answers into the requirements before procurement, and ask the vendor to name the exact file, licence and version that governs each feature you plan to rely on.
Have counsel review the licence files, the vendor's commercial agreement and any key or subscription terms before you commit to a design. This page does not give legal conclusions. Your review should also cover any embedding model or integrated model provider used at import time, since those services carry their own terms and data flows that sit outside the vector database licence. Record the licence decision in the requirements document so that architecture, security and procurement work from the same assumptions.
Compliance evidence the store must produce
What access control evidence should a vector database produce for an audit?
The evidence is a current list of who holds which API keys, roles and per-collection permissions, plus the configuration that enforces them. Auditors typically ask for the access control list as it stood on a sample date, the process for granting and removing access, and proof that default or shared credentials are gone. Qdrant documents admin and read-only API keys, JWT-based granular access with per-collection read or write permissions, and TLS for REST and gRPC, so exported configuration and key inventories are the artifacts to plan for. Weaviate documents API key, OIDC and RBAC user management, and Milvus documents authentication, TLS and role-based access control. Confirm with your assessor which samples they will draw and how often they expect the list refreshed.
Does Qdrant log API operations for audit purposes?
Yes, Qdrant added JSON audit logging of authenticated API operations in v1.17.0, which is the kind of record an assessor can sample. The logs only help if they are shipped to storage the platform team cannot silently alter, retained for the period your policies require, and linked to the identity that made each call. Confirm which operations are captured, what fields each entry contains, and whether logs cover administrative actions as well as data reads and writes. Other engines in the comparison need their own audit configuration checked during selection, since the same questions apply regardless of product.
What backup and restore records will an auditor expect?
Auditors usually want backup schedules, retention settings, job success records, and restore test results showing that a backup was recovered into a working store and checked. For Qdrant, snapshots are the documented mechanism, so the evidence includes snapshot inventories, storage locations, and records of restores tested against a matching version. Keep the backup scope explicit: vectors, payloads, metadata, configuration and any replicas or derived indexes. Record who approved the restore test, the date, and the outcome. A backup that has never been restored is weak evidence, so plan restore tests as a recurring control.
How do we prove that deleted embeddings are gone?
Deletion evidence shows that a vector point, its payload and any copies were removed when a source record was erased or a contract ended. The record should link the source identifier to the vector identifiers, show the delete request and its timestamp, and confirm the removal in the live store. Snapshots and backups can still hold deleted data, so the evidence must also state how and when those copies expire or are rebuilt. Define this process before ingestion, because tracing vectors back to source documents is hard to add later. Confirm with counsel which deletion standard applies to your data.
Does the EU AI Act require logs from a vector database?
It depends on whether the system that uses the store is a high-risk AI system under the Act, which counsel must confirm for your use case. If it is, Article 12(1) requires that high-risk AI systems technically allow automatic recording of events over their lifetime, and Article 19(1) requires providers to keep those logs for at least six months unless other law provides otherwise. The vector store is one component, so the logs that matter are those that show retrieval activity tied to the AI system, such as which collection was queried, by which identity, and when. Agree with your legal team which logs belong to the AI system and which to the database, and where each is kept.
What evidence shows that a vector database was configured securely?
Assessors want a dated configuration baseline, change records, and proof that the baseline was tested. Qdrant's security documentation states that self-deployed instances listen on all interfaces and have no authentication by default, so the baseline should show bound addresses, enabled authentication, TLS settings, and network rules. Keep infrastructure-as-code or configuration files under version control, with approvals for each change. Scan results, vulnerability remediation records and version history for the deployed release are also common requests. DeployOpen prepares these controls and evidence for an assessment, but independent auditors and certification bodies are the ones who assess them.
Who produces this evidence, and what does an implementation partner cover?
The organization owns the evidence, and an implementation partner can design the controls, configure the platform to produce the records, and document how each record is gathered. DeployOpen plans, implements, hardens, backs up and documents self-hosted platforms in your own infrastructure, and it prepares systems, controls and evidence for compliance assessments. It does not issue audit reports, attestations or certifications. Define the evidence list in the written scope before work starts, including who reviews it, where it is stored, and how often it is refreshed. Ongoing evidence collection can be covered by a retainer if your team wants that continuity.
How to get the requirements signed off before choosing a platform
This sequence turns the requirements checklist into a signed decision, so the engine is chosen against agreed owners, data classes, scale targets, restore rules and proof-of-concept results rather than vendor preference. Each step closes with a record that a reviewer can check.
Name owners for each decision area
Before any engine is discussed, name one accountable owner each for data, security, platform engineering and compliance. The data owner confirms which sources feed the embedding pipeline, the security owner signs off on authentication, RBAC and TLS, the platform owner accepts storage and high availability constraints, and the compliance owner confirms which obligations apply. Each owner initials their rows in the checklist. The step is done when every row in the checklist has a named owner and a written date of agreement, and no row is left to the project team by default.
Classify the documents and records to be embedded
List every source that will be chunked and embedded, such as policies, client files, clinical notes, case records or support tickets, and assign each a data classification under the organization's own scheme. Record whether the embeddings carry the same sensitivity as the source, who may query each class, and how long derived vectors must be kept. Include the embedding model and where it runs, since that determines the data flows that must be documented. The output is a classified source inventory that the security and compliance owners have approved. Without it, filtering, tenancy and deletion rules cannot be written.
Set scale, dimensions and recall targets
Write down the expected number of vectors, the embedding dimension for the chosen model, the growth rate, the query rate at peak and the minimum acceptable recall for the use case. Ask the platform owner to translate these into memory, disk and node estimates, and ask the engine vendor or partner to show how those figures were derived from their own sizing guidance. Confirm whether filtering must work on payload fields at query time, and whether hybrid keyword and vector search is needed. The step closes when the targets are signed by the data and platform owners and an assumptions sheet records every input.
Agree the restore objective and backup rules
Define the recovery point and recovery time the business accepts for the vector store, and state whether the source documents can be re-embedded instead of restored from backup. Decide which backup artifacts are kept, such as collection snapshots or a dump of the source records with pinned embedding model versions, and how long they are retained. Include deletion: any backup that still holds erased content needs a documented expiry. The compliance and platform owners sign the restore rules, and the step closes only when a restore has been scheduled for testing in the proof of concept.
Fix the multi-tenancy and access model
Decide whether the store serves one organization, several business units or several customers, and choose the isolation level the engine can support: separate instances, separate collections, partitions or payload-based tenant keys. Write down who can read, write and administer each collection, and how entitlements from the identity provider map to vector queries so users only retrieve content they may see. The security owner confirms the model against the classification from the earlier step. The output is a signed access matrix covering API keys, role definitions and audit logging requirements.
Confirm licence and deployment terms
Check the licence of each shortlisted engine and any optional components, and confirm whether the chosen tier includes the features the access model needs, such as RBAC, SSO, audit logging or high availability. Note any distinction between open-source code and enterprise directories or license keys, and confirm the terms with the vendor in writing where they are unclear. The legal or procurement owner records the result alongside the hosting decision, including whether the engine will run in the organization's own accounts, data centers or air-gapped network.
Run a proof of concept on representative data
Load a representative sample of classified documents into two or three shortlisted engines, using the same embedding model, dimensions and filters. Measure recall against a labeled set of expected results, query latency at the target rate, filtering accuracy, and whether entitlement rules hold under test users. Rehearse a restore from a snapshot and a re-embedding run, and confirm that a deleted source record is removed from the index and from the backups. The step closes when each test has a recorded pass or fail result and the reasons for any failures are written down.
Record the decision and its evidence
Write a decision record that lists the signed checklist rows, the chosen engine and deployment model, the proof-of-concept results, the open risks and the owner accepting each risk. Store the test scripts, configuration files and restore logs with the record so an auditor or internal reviewer can trace each requirement to a result. Schedule a review trigger for changes in scale, data classes or licence terms. The decision is complete when the record is approved by the four owners named in the first step.
Questions buyers ask before hiring help with vector database requirements
How much effort does the vector database requirements work take?
The effort depends on how many data sources feed the store, how many compliance regimes apply, and how the tenancy model is set. A single internal document set with one user group is a much smaller exercise than several source systems with different retention rules and customer-isolated collections. The work covers scale and dimensions, filtering and hybrid search, authentication and RBAC, backup and restore rules, high availability, the embedding pipeline and licence terms. Each of these needs a decision with an owner, so the number of open decisions is the best early indicator of effort. Ask any partner to list the decisions and the people who must sign them off before agreeing scope.
How long does a vector database requirements engagement usually run?
Duration follows the same drivers as effort: source count, compliance scope, tenancy model and how quickly the internal team can answer. Teams with clear data owners and documented controls usually move faster than teams that must first establish what their documents contain or who may see them. Because each organization's sources and approvals differ, no general duration applies to every case. Ask for a timeline in the written scope that lists the dependencies, such as access to environments, data owner interviews and approval meetings, so that delays are visible early.
What does our internal team need to provide for the engagement?
Three things matter most. First, named data owners who can say what each source contains, how it is classified and how long it must be kept. Second, access to the target environment, including cloud accounts, data center networks or air-gapped segments, plus the identity provider and key management services the vector store must integrate with. Third, a named approver who can accept requirements and trade-offs on behalf of the business and security teams. Without the approver, decisions on filtering, tenancy and restore objectives tend to stall. Confirm these roles with the partner before work starts.
Can our own team run the vector database requirements checklist without a partner?
Yes, a capable internal team can work through the checklist, especially when it has engineers who know the embedding pipeline and an owner for security and compliance. The checklist itself is a set of questions, and the answers depend on your data and controls. A partner adds value where the team lacks recent hands-on experience with the candidate engines, such as Qdrant, Milvus, Weaviate or PostgreSQL with pgvector, where the requirements touch several compliance regimes, or where the team needs an independent challenge to assumptions about authentication, restores and multi-tenancy. DeployOpen plans, implements, hardens and documents self-hosted platforms inside the client's own infrastructure, and can scope the requirements work as a fixed-scope engagement.
What does a fixed-scope quote for vector database requirements include?
A quote follows from written scope. DeployOpen does not publish a price list, so the quote reflects the agreed scope, deliverables and timeline. Ask the partner to state which sources, environments, compliance regimes and tenancy models are covered, which documents will be delivered, such as the requirements record and decision log, and what is excluded. Confirm whether follow-on work such as implementation, testing or ongoing support is priced separately, and whether any retainer applies after delivery. Comparing quotes is only useful when they describe the same scope.
Which requirements cause the most rework if they are decided late?
Engineers and security reviewers usually point to four areas. Authentication and RBAC matter because a self-deployed Qdrant instance listens on all interfaces and has no authentication configured by default, so access control must be designed before the store is exposed. Filtering and tenancy determine whether users only retrieve content they may see, which is hard to retrofit. Backup and restore rules define what must be recoverable and how deletion propagates to snapshots. Embedding pipeline integration decides how changed source records trigger re-embedding. Settling these early reduces rework in later stages.
Do the requirements have to match a specific compliance framework?
Not always, but the requirements should record which obligations apply, because they set evidence needs. For example, the EU AI Act's Article 12(1) requires high-risk AI systems to technically allow automatic recording of events over the system's lifetime, and Article 19(1) requires providers to keep those logs for at least six months unless other law provides otherwise. Whether a vector store falls within such obligations depends on the system it serves, so confirm that with legal or compliance owners. DeployOpen prepares systems, controls and evidence for compliance assessments, but does not issue audit reports or certifications; independent auditors and certification bodies do that work.
Which licence terms should the requirements cover for the candidate engines?
Licence terms belong in the requirements because they determine what you may run, distribute and offer to users. Qdrant's open-source engine is Apache-2.0 licensed, and Milvus is Apache-2.0 licensed. Weaviate's LICENSE file places code outside its enterprise directory under BSD-3-Clause, while code in the separate enterprise directory needs a Weaviate enterprise license and enterprise features are enabled by a license key. Ask your legal team which features your design depends on and confirm them against each project's current license file and the vendor's terms before selection.
How DeployOpen scopes and delivers vector database selection and implementation
DeployOpen turns the requirements in this checklist into a written scope before any platform is installed, then plans, implements, hardens, documents and hands over the vector database inside the client's own cloud account, data center or air-gapped network. Engagements are fixed-scope, with deliverables and timelines agreed in writing first.
How we scope
- Workshops to record scale, vector dimensions, filtering and hybrid search needs for each collection.
- Written decisions on multi-tenancy model, authentication, RBAC roles and per-collection permissions.
- Agreed backup, restore, HA and licence review points, with the scope and deliverables confirmed in writing.
How we build
- Deploy the chosen engine, such as Qdrant, Milvus, Weaviate or pgvector, in the client's infrastructure with storage that meets its requirements.
- Configure TLS, API keys or OIDC, RBAC, audit logging and network exposure before any data is loaded.
- Connect the embedding pipeline and test filtering, hybrid search and restore procedures against agreed acceptance criteria.
How we hand over
- Architecture, configuration and runbook documentation covering backup schedules, restore steps and upgrade procedures.
- Compliance evidence packs that show access controls, logging and recovery tests for the client's assessors.
- Knowledge transfer sessions so the client's operations team can run, monitor and restore the database independently.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers after handover.
- Version-matched upgrades and restore tests scheduled with the client's change process.
- Periodic security testing of the vector store and its surrounding APIs, scoped in writing.

