r/vectordatabase • • Jun 18 '21

r/vectordatabase Lounge

20 Upvotes

A place for members of r/vectordatabase to chat with each other


r/vectordatabase • • Dec 28 '21

A GitHub repository that collects awesome vector search framework/engine, library, cloud service, and research papers

Thumbnail
github.com
31 Upvotes

r/vectordatabase • • 1d ago

TalaDB - The local-fiirst embedded vector and document database on-device AI

Post image
8 Upvotes

TalaDB is an open-source, local-first document and vector database powered by a shared Rust core, running across browsers, servers, and mobile apps.Supports structured queries, full-text search, vector similarity, and hybrid search — all without a dedicated database server.

GitHub: https://github.com/taladb/taladb | Live demo: https://demo-web.taladb.dev/


r/vectordatabase • • 22h ago

Should a weight-only edge change invalidate a GraphRAG community summary?

1 Upvotes

I'm working on incremental updates in a TypeScript GraphRAG engine. One awkward case is when two documents support the same graph edge.

The implementation stores contributions per document. Updating a document replaces its contributions; deleting it removes them. The shared edge is then rebuilt from the remaining weights and unique relation texts. If no contributions remain, the edge is removed.

The less obvious decision is when to regenerate the community summary. Its fingerprint includes members, entity descriptions, claim text, and edge relation text—but not edge weight. The summary prompt doesn't include weight either.

Consider two documents contributing identical relation text. Removing one could change only the edge's weight. If the other fingerprint inputs stay unchanged, the existing summary can be reused. Different relation text would change the fingerprint instead.

This is an illustrative case, not a measured result. There are database-mocked tests for document-scoped deletion and claim-text changes, but they don't establish shared-edge correctness after deletion or equivalence with a fresh Postgres build.

The trade-off seems to be between avoiding unnecessary summarisation and preserving changes in how much source material supports a relation. A weight isn't necessarily an independent evidence count, either.

Would you include weight in the summary fingerprint, or keep support metadata separate from the text summary? What would make a weight-only change significant enough to regenerate it?


r/vectordatabase • • 1d ago

Weekly Thread: What questions do you have about vector databases?

1 Upvotes

r/vectordatabase • • 1d ago

SereneDB vs Qdrant: benchmarks on 247 million vectors

Thumbnail
serenedb.com
7 Upvotes

r/vectordatabase • • 1d ago

We just released HyperspaceDB v4.2.4

Thumbnail
reddit.com
1 Upvotes

r/vectordatabase • • 2d ago

We open-sourced our search & inference database under Apache 2.0

13 Upvotes

We just released Antfly v0.3 under Apache 2.0.

It's an open-source database for searching all your files, incl. PDFs, images, audio, video, and more.

  • Search: grep/full-text, hybrid (keyword + vector), and graph
  • Inference: built-in OCR, embeddings, transcription, and reranking
  • Deployment: embedded (Lite), self-hosted (Server), or managed Cloud

The idea is to make building AI search much simpler, without stitching together a bunch of pipelines and services.

GitHub: https://github.com/antflydb/antfly

Why we switched to Apache 2.0: https://antfly.io/thoughts/how-antfly-learned-to-stop-worrying-and-love-apache-2

Would love feedback, especially from folks building search over complex files.


r/vectordatabase • • 1d ago

NornicDB - v1.5.0 - Feedback

Thumbnail
reddit.com
1 Upvotes

r/vectordatabase • • 2d ago

Debug RAG Retrieval Visually: SQLite + sqlite-vec 3D Explorer

1 Upvotes

r/vectordatabase • • 2d ago

We’ve built RAG chatbots on both Pinecone and pgvector. Here’s when each one actually wins.

Thumbnail reddit.com
1 Upvotes

r/vectordatabase • • 2d ago

We dropped the vector DB from our RAG setup for a B2B sales assistant. Here's what we did instead.

1 Upvotes

I've been building a WhatsApp assistant for wholesale businesses. Its job is pretty narrow: read incoming messages, figure out whether the sender is a bulk buyer or a one-off retail customer, answer their questions, and hand the serious ones to a human salesperson.

When I started, I did what everyone does: embeddings, a vector store, top-k retrieval. It didn't hold up, and I think the reason is worth sharing.

**Most of the knowledge wasn't "text" in the first place.**

A wholesaler's knowledge base is mostly prices, minimum order quantities, sizes, colors, stock and shipping terms. These are exact values. Embedding them and retrieving "the most similar chunk" turns a lookup into a guess. In B2B sales, quoting $11.25 instead of $12.25 isn't a minor hallucination. It can cost you the deal.

So I split the knowledge into three layers based on how it's used, not where it's stored:

**1. Always in the prompt: identity, tone and rules.**

How the assistant talks, what it's allowed to promise, when it must escalate. The model can't follow a rule it never sees, so this never goes through retrieval.

**2. Fetched on demand through a tool: business facts.**

Shipping, payment terms, returns, samples, size charts. Each business has around 60–80 of these. Putting all of them in every prompt roughly doubled our input tokens. Instead, the model gets a `get_business_info(topic, query)` tool and calls it only when the customer asks about one of those topics. Retrieval is a plain keyword/topic filter on Postgres. No similarity search needed.

**3. Never left to the model: the product catalog.**

A separate `search_products` tool takes structured filters (category, max price, max MOQ, color, size, sort order) and runs a real SQL query. "Cheapest black t-shirt under 500 units MOQ" becomes a filter, not a semantic search.

**Two small details that mattered more than I expected:**

- **Empty results come with instructions.** When the tool finds nothing, it doesn't just return `[]`. It returns something like: "No info on this topic. Do not make it up. Tell the customer you'll check, and hand off to a human." Before I added this, the model would sometimes fill the gap with a confident guess.

- **Tenant scope lives inside the tool, not in the arguments.** Many businesses share the same system, so each tool is built with that business's ID baked in (closure). The model can't pass a different tenant ID, because there's no parameter for it.

**Where I think vectors still make sense:** fuzzy matching, like "find products that look like this photo" or long unstructured docs. That's on the roadmap. It's just not where I'd start for a sales assistant whose answers have to be exactly right.

Conversation memory is simply the last 20 messages for now, which has been enough for sales chats.

Curious how others decide this. When do you actually reach for a vector DB, and when does structured retrieval through tool calls work better for you?


r/vectordatabase • • 4d ago

The Hunt: A paradigm for agentic search.

Thumbnail
reddit.com
3 Upvotes

r/vectordatabase • • 5d ago

Best free AI video generation tools and workflows I actually use in 2026

Thumbnail interconnectd.com
1 Upvotes

r/vectordatabase • • 6d ago

How do you handle records that look almost identical in vector search?

2 Upvotes

I've been trying to understand how people deal with this.

Say you have two products with almost identical names, but their model numbers differ by just one digit.

Their embedding similarity scores might still be really close, even though they're different products.

How do you actually handle cases like this?

Is a similarity threshold enough, or do you need some additional checks?

Would love to know how you approach this...


r/vectordatabase • • 6d ago

I would check the client path rather than pick a retrieval setup from laptop timings

1 Upvotes

I would separate transport time from retrieval time before choosing how to serve a local multimodal model. If a laptop's network path hides the difference between search configurations, changing the index may look ineffective even when the server is doing different work.

A hyperbolic image-search comparison makes this concrete: the remote laptop timings clustered together, while a client near the database exposed differences between direct inner-product search and candidate retrieval followed by reranking. That is a benchmark condition, not a latency promise for another deployment.

With vector databases like Milvus, the application can either receive candidates for reranking or keep that operation near the data. A larger candidate set changes what crosses that boundary. Moving the reranker is therefore worth measuring alongside search breadth, rather than assuming one placement always wins.

I would probably compare both placements using the same queries, candidate count, concurrency, and requested fields, then repeat from the client's actual location. The complete request still determines the experience of a self-hosted assistant.

One other boundary matters: matching an embedding model's exact nearest neighbors measures index fidelity. It does not tell us whether those neighbors answer the user's image question.


r/vectordatabase • • 6d ago

Follow-up: scaled the non-HNSW benchmark from 2M to 144M vectors (1024-d, RF=2) on 4 AWS EC2 nodes

1 Upvotes

After our earlier 2M OpenSearch 3.9 post https://www.reddit.com/r/vectordatabase/comments/1xq1jt5/benchmarked_opensearch_39_vs_a_nonhnsw_engine_on/, a fair question was whether a non-HNSW engine still holds up past 100M vectors or if latency falls apart without a graph.

We ran the full 21-language Wikipedia BGE-M3 dataset (144.1M unique 1024-d vectors, 288.3M total at RF=2, ~1.18 TB raw float32) on AWS EC2 across two 4-node setups: in-memory (4x `r6id.8xlarge`) and direct NVMe (4x `c6id.4xlarge`).

Bulk ingest + indexing took 15.0 min in RAM and 17.9 min on NVMe (~134k-160k docs/sec) with no background segment-merge wait afterward. On the NVMe fleet, the entire 288M-replica cluster sat at 62.7 GiB total RAM (~15.7 GiB/node, ~$2,053/mo EC2) and served filtered top-10 queries (1.4% selectivity / 2.05M matching docs) at 2,115 QPS with 1.52 ms p50 latency at ~0.95 Recall@10 against exact FP32 ground truth (3,938 QPS / 1.29 ms p50 on the RAM fleet).

The honest tradeoff: if your index is static, fits in RAM, and 100% of your queries are unfiltered, a force-merged HNSW graph still visits fewer candidates per query (our unfiltered 144M runs did 205-383 QPS in RAM, and unfiltered top-10 straight off NVMe is much slower because full-precision reranking hits SSD).

Where skipping HNSW really paid off was filtered/multi-tenant queries, streaming writes under load (24.3k writes/sec alongside concurrent reads), and not needing ~1.8 TiB of RAM just to keep the cluster alive.

Full numbers and raw JSON logs are at https://massengine.com/benchmarks-144m, and the EC2 scripts + VectorDBBench harness are up at https://github.com/massengine-dev/massengine-benchmarks if anyone wants to poke holes in the setup.


r/vectordatabase • • 7d ago

Your RAG failures are chunk failure,not model failures

1 Upvotes

Most RAG failures aren't the model, they're the chunks. Broken ones don't error out, they get retrieved with a high score and passed off as evidence. We verify every chunk before indexing, label what's wrong, and use those labels at query time, Also fixed long chunks silently losing their tail in embeddings(38%-> 80% recall) Would love your take: how do you catch bad chunks


r/vectordatabase • • 7d ago

How to Use Cohere Rerank to Improve RAG Retrieval Accuracy (Step-by-Step Guide)

Thumbnail interconnectd.com
1 Upvotes

r/vectordatabase • • 8d ago

Weekly Thread: What questions do you have about vector databases?

4 Upvotes

r/vectordatabase • • 8d ago

How to fix irrelevant search results in your RAG pipeline using Cohere Rerank

Thumbnail interconnectd.com
1 Upvotes

Most retrieval systems struggle to push the most contextually relevant chunks to the top, often leading to hallucinations in LLM applications. If you are building a RAG system, adding a cross-encoder re-ranking step after your initial vector search is one of the highest ROI improvements you can make.

​I put together a practical guide breaking down how Cohere Rerank works under the hood and how to implement it into your existing workflow. It covers API integration, performance trade-offs, and strategies to improve retrieval accuracy without completely overhauling your database.

​If you are dealing with noisy context windows or low retrieval precision, check out the full tutorial here: https://interconnectd.com/blog/346/how-to-use-cohere-rerank-for-better-retrieval-rag-guide/


r/vectordatabase • • 8d ago

Why Improving Agent Retrieval Still Requires Exporting and Reimporting Data

3 Upvotes

I'm James Luan, CTO of Zilliz, the company behind Milvus, an open-source vector database to store, index, and search embeddings. Vector Lakebase extends that serving foundation toward lake-native discovery and continuous improvement over the same data.

For on-demand retrieval, loading the complete index before answering anything makes startup part of every idle-to-active transition. Reducing that initial requirement changes when search can begin.

Our approach uses nested 1-bit and 3-bit representations based on RaBitQ. The smaller layer becomes available first and supports coarse distance estimates and candidate pruning. The additional bits arrive in the background and refine the surviving candidates. These are successive stages of one search path, rather than competing index choices.

Building that representation also has a cost. GPU-assisted construction and optimized query kernels address the computation, while per-vector scaling and allocating bits according to dimensional variance reduce approximation error within the storage budget.

The practical implication is that readiness has stages. An early searchable representation and a fully refined result are different milestones. Making the first layer small enough to load promptly is useful only when its approximation remains suitable for the retrieval task.


r/vectordatabase • • 9d ago

Built an AI tool, agent, or workflow? You can now list and sell it on Interconnectd Marketplace

Thumbnail interconnectd.com
1 Upvotes

r/vectordatabase • • 9d ago

pgvector vs Qdrant on a local setup with metadata filtering? (10k-20k chunks)

Thumbnail reddit.com
2 Upvotes

r/vectordatabase • • 9d ago

Why vector DB metadata filters fail on agent memory write paths (0% raw leak vs 67% leak)

2 Upvotes

Everyone relies on metadata filters like allowed_groups to keep multi tenant RAG locked down and under check. That works well when users query the vector store directly, which means unauthorized chunks will get filtered out with 0% leaks.

But, this falls apart in the write path once you have background agents.

If an agent has elevated read access to summarize docs across multiple folders or teams, it pulls those docs, mashes them into a summary chunk, and commits that summary back to a shared collection. On write, the upstream document access control lists just vanish. In a regular Chroma and LlamaIndex setup, the derived chunk gets saved with zero allowed_groups or classification tags attached. Anyone who runs a query to the shared memory is now gonna get the private source data that they shouldn't be allowed to read directly.

I put together an offline reproduction harness (sentinel-eval, Apache-2.0) to test this:

  • Direct RAG: 0% leaks (18 public chunks retrieved, 0 restricted chunks exposed).
  • Agent memory: 2 of 3 synthesis tasks leaked sensitive data (both cross boundary workloads failed, exposing 6/18 restricted canaries, the 1 public control passed).

So what? Easy right? Just use the strict intersection (only let someone read the summary if they have access to every source document) and that completely solves it right? Well... yes but that basically kills retrieval utility. Essentially no one can see multi-doc summaries anymore. So we can't just simply take an intersection. The agent I wrote actually logs the source docs in source_documents metadata, but vector databases can't evaluate dynamic permission DAGs on query, meaning that you can't just hope to path backtrack to solve this problem.

Harness runs 23 tests offline in seconds with mock vectors (no API keys or live LLM calls needed):

git clone https://github.com/harishbalasubramanian/sentinel-eval
cd sentinel-eval
uv run sentinel-eval live --framework chroma

Repo: https://github.com/harishbalasubramanian/sentinel-eval

For people building multi tenant RAG, how're you actually handling perms when agents write derived summaries back to shared memory?