So let's start with the graph that you just mentioned. What is it? What does it do?
For so many use cases. Let's say you are a major CPG company. This is a lot of what we do at L'Oréal, at Kendra Scott, et cetera. Regulatory affairs and compliance are using Writer to go through federal guidelines, federal regulations, stuff that's getting updated in real time, to produce arguments for why we've got the packaging that we do or why we can make the claims that we do. When you are doing this desktop-based research using LLMs, both to go in and digest the regulations and then actually build and write the report, these are great use cases for us that produce a ton of value.
Are not going to be asking the LLM directly those questions. You are going to be using an app that uses a RAG pipeline to be able to really get that data into the LLM. We do have domain-specific LLMs, but for a use case like that, you need to set up RAG. A lot of times, and we almost always—we're not as big as Microsoft or OpenAI yet, right? So we're the brand that is coming in and the company that's coming in when there's already a DIY project, right?
Like, these companies have all been trying to crack the nut for the last couple of years. There is something that just hasn't scaled when we are talking to customers. And so we just have to beat the benchmark. And starting a couple years ago, we realized that we were just like the customer, building these pretty brittle, hard-to-maintain, hard-to-scale applications by using—and I won't name names—but we are using folks that everybody uses as partners.
And it was just very hard. And we were some of those partners' biggest customers in the early days and helped them raise money and all the things. But it's just really been hard to scale that. And so our graph-based approach is radically different. I mean, we trained a separate LLM—this is our brilliant AI team—to build basically the triples. I mean, it is a flat JSON file. This is stored in a Postgres database. It's not even a graph database.
You don't need an ontology. But because the LLM is so good at building the graph, paired with things we're doing on the index, we do something called retrieval-aware compression. So we're making most use of that context window by just how we compress the data that goes in with a query. And then we actually use the memory layer of the LLM. So it's a technique called Fusion-in-Decoder. It came out of FAIR that we integrated into our approach. So we built a whole product to solve a really, really important part of getting things right, and it's why it's magical out of the box.
It's why you plug in your data; you're not doing any preprocessing literally when you build a graph in Writer. And the words RAG appear nowhere in our product, by the way. It's just literally like, upload your file, connect via data connector. Here's the API if you're going to send files, and it just works. And that's really what you need to be able to then go solve all the other problems, right? Accuracy is just one.
So graph-based RAG is sort of the cool term du jour, the cool approach du jour compared to vector-based. Can you maybe compare and contrast?
In a vector-based approach, what you're doing—and I'm grossly oversimplifying here—let's say we are looking at an insurance policy. And in your head, imagine that you've got an insurance policy that's actually scanned, and you've got tables, and you've got two or three columns on every page, and there's tables nested within that insurance policy. That is like good data when you're talking to the enterprise, right? And if you are taking a vector-based approach to answer a question like, I'm talking to a client, and here is their policy, and they want to know what's the coverage maximum if the trailer gets rear-ended or whatever.
When you are doing a vector-based approach, you're going through and you've chunked that policy. And against the prompt, you are trying to find the most relevant chunks in that policy, which means it does really badly with tables because you've flattened out the document. You have no context for where this nested table is in an insurance policy. It does really poorly with numbers, and it does really poorly when you've got lots of policies that are all talking about trailers getting rear-ended. And there's a ton of techniques to be able to get the signal from the noise in these chunks, but it requires a lot of processing.
And when that policy, even one policy, gets updated, you're throwing away the entire embedding store and starting over. Compare that to a graph-based approach where we've automatically created the nodes and edges that build the relationships and help us understand where these concepts land and how they're related to each other. So when we're going in and coming up with the relevant chunks—it's a different concept, but comparable—we're sending much more relevant data to the model, and so when you pair that with other techniques around the retrieval index and the Fusion-in-Decoder for limiting hallucinations, you just get much better accuracy out of the box.
And that's where it starts. And being able to really visualize literally the nodes and edges of the graph helps us help the customer understand where there's actually way too much density here and we've got to put in a light ontology or some light curation, or where is it pretty thin? Questions are coming in and there's just no information on this in the knowledge graph. Then the maintenance of it is just way, way cheaper. We were very validated by a Microsoft paper that came out earlier this year, and they called their approach GraphRAG.