My advice for building something like this: don't get hung up on a need for vector databases and embedding.<p>Full text search or even grep/rg are a lot faster and cheaper to work with - no need to maintain a vector database index - and turn out to work really well if you put them in some kind of agentic tool loop.<p>The big benefit of semantic search was that it could handle fuzzy searching - returning results that mention dogs if someone searches for canines, for example.<p>Give a good LLM a search tool and it can come up with searches like "dog OR canine" on its own - and refine those queries over multiple rounds of searches.<p>Plus it means you don't have to solve the chunking problem!
I created a small app that shows the difference between embedding-based ("semantic") and bm25 search:<p><a href="http://search-sensei.s3-website-us-east-1.amazonaws.com/" rel="nofollow">http://search-sensei.s3-website-us-east-1.amazonaws.com/</a><p>(warning! It will download ~50MB of data for the model weights and onnx runtime on first load, but should otherwise run smoothly even on a phone)<p>It runs a small embedding model in the browser and returns search results in "real time".<p>It has a few illustrative examples where semantic search returns the intended results. For example bm25 does not understand that "j lo" or "jlo" refer to Jennifer Lopez. Similarly embedding based methods can better deal with things like typos.<p>EDIT: search is performed over 1000 news articles randomly sampled from 2016 to 2024
<a href="https://www.anthropic.com/engineering/contextual-retrieval" rel="nofollow">https://www.anthropic.com/engineering/contextual-retrieval</a><p>Anthropic found embeddings + BM25 (keyword search) gave the best results. (Well, after contextual summarization, and fusion, and reranking, and shoving the whole thing into an LLM...)<p>But sadly they didn't say how BM25 did on its own, which is the really interesting part to me.<p>In my own (small scale) tests with embeddings, I found that I'd be looking right at the page that contained the literal words in my query and embeddings would fail to find it... Ctrl+F wins again!
Do you have a standard prompt you use for this? I have definitely seen agentic tools doing this for me, e.g., when searching the local file system, but I'm not sure if it native behaviour for tool-using LLMs or if it is coerced via prompts.
In my experience the semantic/lexical search problem is better understood as a precision/recall tradeoff. Lexical search (along with boolean operators, exact phrase matching, etc.) has very high precision at the expense of lower recall, whereas semantic search sits at a higher recall/lower precision point on the curve.
Yeah, that sounds about right to me. The most effective approach does appear to be a hybrid of embeddings and BM25, which is worth exploring if you have the capacity to do so.<p>For most cases though sticking with BM25 is likely to be "good enough" and a whole lot cheaper to build and run.
I recently came across a “prefer the most common synonym” problem, in Google Maps, while searching for a poolhall—even literally ‘billiards’ returned results for swimming pools and chlorine. I wonder if some more NOTs aren’t necessary…interested in learning about RAGs though I’m a little behind the curve.
This matches what I found building an AI app for kids. Started with embeddings because everyone said to, then ripped it out and went with simple keyword matching. The extra complexity wasn't worth it for my use case. Most of the magic comes from the LLM anyway, not the retrieval layer.
Hmm it can capture more than just single words though, e.g. meaningful phrases or paragraphs that could be written in many ways.
In my app the best lexical search approaches completely broke my agent. For my rag system the llm would on average take 2.1 lexical searches to get the results it needed. Which wasn’t terrible but it meant sometimes it needed up to 5 searches to find it which blew up user latency. Now that I have a hybrid semantic search + lexical search it only requires 1.1 searches per result.
Simon have you ever given a talk or written about this sort of pragmatism? A spin on how to achieve this with Datasette is an easy thing to imagine IMO.
I built a simple emacs package based on this idea [0]. It works surprisingly well, but I dont know how far it scales. It's likely not as frugal from a token usage perspective.<p>0: <a href="https://github.com/dmitrym0/dm-gptel-simple-org-memory" rel="nofollow">https://github.com/dmitrym0/dm-gptel-simple-org-memory</a>
Are multiple LLM queries faster than vector search? Even with the example "dog OR canine" that leads to two LLM inference calls vs one. LLM inference is also more expensive than vector search.<p>In general RAG != Vector Search though. If a SQL query, grep, full text search or other does the job then by all means. But for relevance-based search, vector search shines.
Perhaps SQLite with FTS5? Or even better, getting DuckDB into the party as it's ecosystem seems ripe for this type of work.
Yes, exactly. We have our AI feature configured to use our pre-existing TypeSense integration and it's stunningly competent at figuring out exactly what search queries to use across which collections in order to find relevant results.
One thing I didn’t see here that might be hurting your performance is a lack of semantic chunking. It sounds like you’re embedding entire docs, which kind of breaks down if the docs contain multiple concepts. A better approach for recall is using some kind of chunking program to get semantic chunks (I like spacy though you have to configure it a bit). Then once you have your chunks you need to append context to how this chunk relates to the rest of your doc before you do your embedding. I have found anthropics approach to contextual retrieval to be very performant in my RAG systems (<a href="https://www.anthropic.com/engineering/contextual-retrieval" rel="nofollow">https://www.anthropic.com/engineering/contextual-retrieval</a>) you can just use gpt oss 20b as the model for generation of context.<p>Unless I’ve misunderstood your post and you are doing some form of this in your pipeline you should see a dramatic improvement in performance once you implement this.
hey, author (not op) here. we do do semantic chunking! I think maybe I gave the impression that we don't because of the mention of aggregating context but I tested this with questions that would require aggregating context from 15+ documents (meaning 2x that in chunks), hence the comment in the post!
Is there a way to convert documents into a hierarchical connected graph data structure which references each other similar to how we use personal knowledge tools like Obsidian and ability to traverse this graph? Is GraphRag technique trying to do this exactly?
Ah so you’re generating context from multiple docs for your chunks? How do you decide which docs get aggregated?
Why is it implicit that semantic search will outperform lexical search?<p>Back in 2023 when I compared semantic search to lexical search (tantivy; BM25), I found the search results to be marginally different.<p>Even if semantic search has slightly more recall, does the problem of context warrant this multi-component, homebrew search engine approach?<p>By what important measure does it outperform a lexical search engine? Is the engineering time worth it?
It depends on how you test it. I recently found that the way devs test it differs radically from how users actually use it. When we first built our RAG, it showed promising results (around 90% recall on large knowledge bases). However, when the first actual users tried it, it could barely answer anything (closer to 30%). It turned out we relied on exact keywords too much when testing it: we knew the test knowledge base, so we formulated our questions in a way that helped the RAG find what we expected it to find. Real users don't know the exact terminology used in the articles. We had to rethink the whole thing. Lexical search is certainly not enough. Sure, you can run an agent on top of it, but that blows up latency - users aren't happy when they have to wait more than a couple of seconds.
This is the gap that kills most AI features. Devs test with queries they already know the answer to. Users come in with vague questions using completely different words. I learned to test by asking my kids to use my app - they phrase things in ways I would never predict.
Ironically, pitting a LLM (ideally a completely different model) up against what you're testing, letting it write human "out of the ordinary" queries to use as test cases tend to work well too, if you don't have kids you can use as a free workforce :)
How did you end up changing it? Creating new evals to measure the actual user experience seems easy enough, how did that inform your stack?
Depends on how important keyword matching vs something more ambiguous is to your app. In Wanderfugl there’s a bunch of queries where semantic search can find an important chunk that lacks a high bm25 score. The good news is you can get all the benefits of bm25 and semantic with a hybrid ranking. The answer isn’t one or the other.
The benefit I see is you can have queries like "conversations between two scientists".<p>Its very dependent on use case imo
> we use Sentence Transformers (all-MiniLM-L6-v2) as our default (solid all-around performer for speed and retrieval, English-only).<p>Huh, interesting. I might be building a German-language RAG at some point in my future and I never even considered that some models might not support German at all. Does anyone have any experience here? Do many models underperform or not support non-English languages?
You can refer to <a href="https://huggingface.co/spaces/mteb/leaderboard" rel="nofollow">https://huggingface.co/spaces/mteb/leaderboard</a> and use that to guide your selection.<p>Check under the "Retrieval" section, either RTEB Multilingual or RTEB German (under language specific).<p>You may also want to filter for model sizes (under "Advanced Model Filters"). For instance if you are self-hosting and running on a CPU it may make sense to limit to something like <=100M parameters models.
> Do many models underperform or not support non-English languages?<p>Yes they do. However:<p>1. German is one of the more common languages to train on so more models will support it than say, Bahasa<p>2. There should still be a reasonable amount of multi-lingual models available. Particularly if you're OK with using proprietary models via API. AFAIK all the frontier embedding and reranking models (non open-source) are multi-lingual
Yes I can confirm that,we had resorted to a multilingual embedding model back in the day. <a href="https://link.springer.com/chapter/10.1007/978-3-031-77918-3_15" rel="nofollow">https://link.springer.com/chapter/10.1007/978-3-031-77918-3_...</a>
When I started playing with this stuff in the GPT-4 days (8K context!), I wrote a script that would search for a relevant passage in a book, by shoving the whole book into GPT-4, in roughly context sized chunks.<p>I think it was like a dollar per search or something in those days. We've come a long way!<p>Anthropic, in their RAG article, actually say that if your thing fits in context, you should probably just put it there instead of using RAG.<p>I don't know where the optimal cutoff is though, since quality does suffer with long contexts. (Not to mention price and speed.)<p><a href="https://www.anthropic.com/engineering/contextual-retrieval" rel="nofollow">https://www.anthropic.com/engineering/contextual-retrieval</a><p>The context size and pricing has come so far! Now the whole book fits in context, and it's like 1 cent to put the whole thing in context.<p>(Well, a little more with Anthropic's models ;)
The hardest part in RAQ is document parsing. If you only consider text then it should be ok, but once you start having tables, tables going multiple pages, charts, ignore TOC when available, footnotes … etc, that part becomes really hard and accuracy suffers to get the context regardless of what chunking do you use.<p>There are some patterns to help such as RAPTOR where you make ingestion content aware and instead of just ingesting content, you start using LLMs to question and summarise the content and save that to the vector database.<p>But reality is, having one size fits all for RAQ is not an easy task.
I'd like to have a local, fully offline and open-source software into which I can dump all our Emails, Slack, Gdrive contents, Code, and Wiki, and then query it with free form questions such as "with which customers did we discuss feature X?", producing references to the original sources.<p>What are my options?<p>I want to avoid building my own or customising a lot. Ideally it would also recommend which models work well and have good defaults for those.
What we use:
- <a href="https://github.com/ggozad/haiku.rag" rel="nofollow">https://github.com/ggozad/haiku.rag</a><p>Why?<p>- developer oriented (easy to read Python and uses pydantic-ai)<p>- benchmarks available<p>- docling with advanced citations (on branch)<p>- supports deep research agent<p>- real open source by long term committed developer not fly by night
Interesting perspective on the use of full-text search over vector databases for RAG. I appreciate the insights on agentic tool loops and handling fuzzy searching.
When it comes to the evals for this kind of thing, is there a standard set of test data out there that one can work with to benchmark against? ie a collection of documents with questions that should result in particular documents or chunks being cited as the most relevant match.
I kinda do want to build a local RAG? I want some significant subset of Wikipedia (I assume most people know about these) on a dedicated machine with a RAG front-end. I would have then an offline Wikipedia "librarian" I could query.<p>But I'm lazy and assumed that someone has already built such a thing. I'm just not aware of this "Wikipedia-RAG-in-a-box".
I'm interested in the embeddings models suggested. I had some good results with nomic in a small embedding based tool I built. I also heard a few good things about qwen3-embedding, though the latency wasn't great for my usecase so I didn't pursue it much further.<p>Similarly, I used sqlite-vec, and was very happy with it. (if I were already using postgres I'd have gone with that, but this was more of a cli tool).<p>If the author is here, did you try any of those models? how would you compare the ones you did use?
You can get local RAG with Anythingllm if you want minimal effort too fwiw. Pretty much plug and play. Used it for simple testing for an idea before getting into the weeds of langchain and agentic RAG.
> What that means is that when you're looking to build a fully local RAG setup, you'll need to substitute whatever SaaS providers you're using for a local option for each of those components.<p>Even starting with having "just" the documents and vector db locally is a huge first step and much more doable than going with a local LLM at the same time. I don't know any one or any org that has the resources to run their own LLM at scale.
For an open source, local (or cloud) vector DB, I would also recommend checking out Chroma (<a href="https://trychroma.com" rel="nofollow">https://trychroma.com</a>). It also supports full text search. Disclaimer: I work on Chroma cloud.
I built this for local RAG <a href="https://github.com/kbrisso/byte-vision" rel="nofollow">https://github.com/kbrisso/byte-vision</a> it uses llama.cpp and Elasticsearch. On a laptop with 8 GB GPU it can handle a 30K token size and summarize a fairly large PDF.
If you end up using any of the frontier models, don't forget to protect private information in your prompts - <a href="https://github.com/deepanwadhwa/zink" rel="nofollow">https://github.com/deepanwadhwa/zink</a>
You can vibe code a local RAG with or without vectors in 5 minutes. Like another commenter pointed out, unless your corpus is huge, you do not need vectors, but hey using vectors is fun so why not.<p>For what its worth, I run a local first, small model, private RAG that uses LangGraph, Neo4J knowledge graphs, I swap the models around constantly. It mostly just gets called by agent tools now.
No
Interesting stack. I’ve been working on doing something like this with Apple specific tech. Swiftdata is not easy to work with.
How does this compare with orama?
Rust API?
Glad to see all the interest in the local RAG space, it's been something I've been pushing for a while.<p>I just put this example together today: <a href="https://gist.github.com/davidmezzetti/d2854ed82f2d0665ec7efdd073d575d7" rel="nofollow">https://gist.github.com/davidmezzetti/d2854ed82f2d0665ec7efd...</a>