Skip to content
DeepMind’s RAG System with Animesh Chatterji and Ivan Solovyev episode artwork

Mar 12, 2026 40 min

DeepMind’s RAG System with Animesh Chatterji and Ivan Solovyev

from Software Engineering Daily Hosted by softwareengineeringdaily.com

Retrieval-augmented generation, or RAG, has become a foundational approach to building production AI systems. However, deploying RAG in practice can be complex and costly. Developers typically have to manage vector databases, chunking strategies, embedding models, and indexing infrastructure. Designing effective RAG systems is also a moving target, as techniques and best practices evolve in step with rapidly advancing language models. Google DeepMind recently released the File Search Tool, a fully managed RAG system built directly into the Gemini API. File Search abstracts away the retrieval pipeline, allowing developers to upload documents, code, and other text data, automatically generate embeddings, and query their knowledge base. We wanted to understand how the DeepMind team designed a general-purpose RAG system that maintains high retrieval quality. Animesh Chatterji is a Software Engineer at Google DeepMind and Ivan Solovyev is a Product Manager at DeepMind, and they worked on File Search Tool. They joined the podcast with Sean Falconer to discuss the evolution of RAG, why simplicity and pricing transparency matter, how embedding models have improved retrieval quality, the tradeoffs between configurability and ease of use, and what’s next for multimodal retrieval across text, images, and beyond. Sean’s been an academic, startup founder, and Googler. He has published works covering a wide range of topics from AI to quantum computing. Currently, Sean is an AI Entrepreneur in Residence at Confluent where he works on AI strategy and thought leadership. You can connect with Sean on LinkedIn. Please click here to see the transcript of this episode. Sponsorship inquiries: [email protected]

Episode details come from the podcast's RSS feed.

Embed this episode

Ready to play

DeepMind’s RAG System with Animesh Chatterji and Ivan Solovyev

0:00 40:57
of matches

Transcript Auto-generated, may contain errors

Retrieval Augmented Generation, or RAG, has become a foundational approach to building production AI systems. However, deploying RAG in practice can be complex and costly. Developers typically have to manage vector databases, junking strategies, embedding models, and indexing infrastructure. Designing effective RAG systems is also a moving target, as techniques and best practices evolve in-step with rapidly advancing language models. Google DeepMind recently released the File Search tool, a fully managed RAG system built directly into the Gemini API.

File Search abstracts away the retrieval pipeline, allowing developers to upload documents, code, and other text data, automatically generate embeddings, and query their knowledge base. We wanted to understand how the DeepMind team designed a general-purpose RAG system that maintains high retrieval quality. Onimesh Chatterjeet is a software engineer at Google DeepMind, and Ivan Salaviev is a product manager at DeepMind, and they worked on the File Search tool. They joined the podcast with John Falconer to discuss the evolution of RAG, why Simplicity and Pricing Transparency Matter, how embedding models have improved retrieval quality, the trade-offs between configurability and ease of use, and what's next for multimodal retrieval across text, images, and beyond.

This episode is hosted by Sean Falconer. Check the show notes for more information on Sean's work and where to find him. Ivan and Ennimesh, welcome to the show. Hi Sean. How's it going to be here?

Awesome. Well, one of we, you know, we have two guests today, just so everyone can kind of learn whose voice is who. When we start off with, Ivan, we'll start with you. You know, who are you and what do you do? Yeah, my name is Ivan.

I'm product manager for File Search on Gemini API. Great. Ennimesh, you? Hi, I'm Ennimesh. I'm the engineer at Ennim, you don't find such.

Awesome. Well, thanks both for being here. So, you know, we're talking about this product, which you mentioned to your File, the Fire solution. And before we get too deep into, I think, sort of some general things around the AI, RAG agents and so on, can you talk a little bit about, you know, what the File Search tool is and what problem it tries to address? Maybe, Ivan, you can take that.

Yeah, absolutely. So, File Search tool, first of all, is an integrated RAC solution that makes it super easy for you to take lots and lots of data, text, PDFs, codes, whatever you have uploaded into Gemma and Start asking questions about your data. There are plenty of RAC pipelines available on the market, like we have Vertex, RAC engine and there are other providers who do support this feature, so it's nothing new. And what we focused on in File Search in particular is accessibility and simplicity of use. We made some opinionated decisions.

We removed a lot of complexity in terms of configuration, set up. You don't need to set up your database. You don't need to set up your infrastructure. The do is just there. You just upload your data and you're going to use it right away.

So we believe this simplicity is something that can help a lot of developers get started and slow-recoms, like a black city or setting up their own pipeline. The other big aspect that we're actually proud of is how we price the whole product. If you compare it to what's available on the market, first of all, the pricing is usually fairly complex. There are multiple components that are coming into the picture. You are paying for storage.

You are paying for inference. You are paying for indexing. Yada yada. What we did was we decided to simplify the whole model. We removed most of the things that you are paying for and we focused on two simple aspects.

So first of all, you are paying for indexing. So whenever you upload a file, you do need to do a lot of complex processing. You need to do embeddings. So, you go back for that. And after that, whenever you do it query to general, like you're just paying for documents.

Obviously, they're going to be some additional from File Search adding data to the context, but that's it. You're not paying for storage. You're not paying for anything else. Why make that change in around pricing? Primarily to just really try to simplify things for the users of this.

Why was it needed to kind of buck the trend of how perhaps people used to have been paying for RAG in the past? Yeah. I think in the general API, we are aiming a lot for simplicity. And we do hear a lot of feedback from developers that it's hard to deal with lots and lots of products. It's hard to deal with different billing models and how the whole cost is being calculated.

So, we do see it as a decent improvement over other products. And the price is actually much cheaper. So, it's a bit better. Okay. I guess the evolution of RAG, obviously, RAG was kind of the buzzword of the moment, I would say, a couple of years ago.

Now there's also, I think, been some things out in the site, guys, like, do we need RAG still? We have agents and RAG is dead. You hear all this kind of stuff. I guess, like, where do you stand on that? And also, can you talk a little bit about sort of the history and how maybe things are approached even RAG and the way that we use it has changed during that time?

Let me talk through what I think, like, where we are with RAG and maybe Animeshkin can chime in on the history of development of this feature. In terms of where we are, I think RAG is a fundamental capability. RAG being there from the very beginning, whenever those models get really popular in use, it was always a staple whenever you wanted to process the data and hype cycles were going up and down or we see this with different features related to LLMs. But I feel that the RAG was always there and it was always useful to some extent. In the latest years, we saw improvements in the context size, obviously, available to LLMs, and this does help a lot with use cases with limited data sets.

And we do see much better quality whenever you try to do with, like, simple, retrieval tasks on a small data sets that fits into the context and usually do recommend to you. However, whenever you start doing any enterprise use cases, whenever you have a huge code base, whenever you have a large file sets, like a legal documentation, anything like that, having RAG becomes very, very beneficial. First of all, you can work with the whole database without building the complicated pipeline or infrastructure to actually juggle the data in and out of the context. You can work with the whole data sets. The cost become much better with RAG.

If you put everything into the context, it becomes expensive, very, very fast, and especially if you're using, like, the higher tier models, like raw models, it's getting expensive and with file search or other RAG solutions, you are able to actually use this cost for the large databases and the large enterprise use cases, that's actually that's fairly, fairly quickly. And, in terms of history, has our techniques and approach to RAG changed over the last couple of years? Has that evolved as well? Yes, I think the use cases have evolved. So I think we have a question where the long context models have straightened the proposition of RAG.

I would say that, in fact, the having raised RAG to cover even more use cases, like there are a lot of video use cases where people want to upload documents, but their entire semester. And there is no even more focus on making RAG efficient because even the long context models that the creativity was working fine, we still see sometimes this context route or lost in the digital syndrome, where models are not created retrieving data, which is kind of in the middle of the context. So now there are new techniques on making sure that how can we improve even the chunks that we are feeding into the model from RAG. So there was a recent paper last year, which is called Refrag, where what they are trying to do is instead of passing the chunks as it is to the model, they are trying to embed the chunks and give all these embeddings to the model and let the model decide which of these embeddings may seem more interesting and only expand those cases.

So yeah, from the kind of initial vanilla RAG where we kind of find everything, give it to the model, we are trying to make that more smart by figuring out which chunks to give. Also the embedding models themselves have improved. The way we are able to represent data that has significantly improved. So now we are better at understanding the context. We are doing better in languages other than English.

So internationalization has also picked up. So there are these different parts using which we can say that RAG is a product is improving. And when you say that, it's kind of like the wrong, I don't know, like question or view to take that around like tool use versus RAG. Are they really competitors or are they more like these are collaborators in some sense? I mean, RAG is in some sense a tool that we give it to the model.

In case there's needs more information from your specific private purpose, this is the way to go. But yeah, I wouldn't really see them as competitors. Yeah, absolutely. And I agree as well. I think that is kind of a misunderstanding of what RAG is to frame it in that way.

But I think it is something that you see out there in the wilds of Twitter, Sierra and so forth. But that's a little bit of the wild west of AI in some sense. In fact, I would say RAG is coming in popular in different ways. Now, we recently are kind of public reviewing the personalization, which enables the model to give more context about your persona. And like the way to enable is again, something like that, when you figure out really when chunks and give it to the model, and then it can understand your persona better and answer queries in that context.

Can you talk a little bit about how that works in terms of being able to determine what are the right chunks to feed in the model? And how do you reduce the error rate of essentially identifying incorrect chunks? I think what we do is when you provide the data, we chunk it and we embed it using the latest Gemini embedding model. And then we basically index it internally. And then at the time of the query, when the user provides the query, we again embed it using the same embedding model.

And then try to figure out the relevant chunks from that part bus that the user has uploaded. And then we have some knobs on which embedding model to use or how many chunks do we want to retrieve and pass it to the model. And we have run a bunch of evals to kind of find the sweet spot in terms of latency of how many chunks we want to retrieve versus the quality VC. And there are some knobs that the users can provide in terms of how they want to chunk the data. But mostly it's the default settings that we have iterated upon.

We have to decide to make sure that the model actually triggers this tool when it actually feels that it is necessary to get more context and it's not necessary to agree. So the entire suite of tools we have kind of evolved and eval through to make sure that we provide the right default settings. And there are some capabilities that the users can override. What is that spot in terms of the number of chunks of return? So I think it's in low-level digits right now.

And we have kind of kept it open. We don't document how many chunks do we want to do that. But yeah, it's not too many at this point of time. Is there some use-case dependency on that? Or can we actually have sort of more of a universal approach to this?

So right now we are going with the one solution fits all approach because we want to keep it similar. And when we hear use-cases of customers who feel the need that they want more of these chunks retrieved, it's easy to expose that as an option in the API. We don't want to do that right now. But if needed, we could do that. If the threshold at which you want to retrieve the chunks or the number of chunks you want to feed to the model, those are all things we could be good.

And even on your writing something? Yeah. So far what we saw from the partner's integration is that the default configuration actually fits most of the use-cases. We do have people doing search of illegal documents. We do have people doing searches over their code databases to provide relevant guidance for code completion and such.

And in all of those cases, somewhere around five chunks returns in the response from file search was fairly well for that. And then in terms of, you know, I think historically if you look at how people have approached a rag, there's a lot of people want to really exert a lot of control over things like chunk over lab chunk size, various settings. So I guess why I'm shacking away a lot of that retrieval pipeline. How do you sort of balance that? Is it that you're targeting a specific type of use case or a specific type of user?

Or have you really figured out the secret sauce of the right collection of those things? It's just going to work for people in the box. I think most of the quality actually comes from the embedding model. So like you should think about this as like 80% of quality embeddings. 20% is your configuration.

So as long as we have the best embedding models, which we do, the rest is less relevant to the quality of the outcome. So we do believe that for most people playing with those configurations will multi-yield significance improvement. And at the time, it's better spent in building their own pipeline. So that's the way we're focused on. At the same time, we never say like don't use any other acro pipelines.

We actually say like file search is the simplest tool. You should try the first thing. We should work for the majority of people. But if you really need the configability, let's say you're using cases very, very complex. You're processing very well structured data, specific tables, specific graphs.

That's our system does not yet recognize well. In that case, you may want to adjust all the little knobs that are coming with the more complicated pipelines. And what kind of files are you capable of indexing? I would love to say all of them. But we are indexing text files mostly.

So PDFs, docs, code files, anything with text. We're currently doing OCR on images. So we're not fully ignoring images within PDFs and other files, but we are going through those. Our system we're extracting text out of them and pulling that into the context as well. And we are actually working on getting the multi-modals of work in as well.

So we want to support native image processing, video processing, and at some point native audio as well. Generally models are pretty good as reasoning on top of image and video data. So we want to have this virtual capability to actually find the relevant images and the content of the context of the channel and what we can see them in the back of them. So for even if you're processing text, there's lots of different types of text files. You could have code to be a text file, you get a markdown, you can have documents that have not just images, but tables and so forth.

So are you able to dynamically figure out the chunking strategy on behalf of essentially the user? Or does it matter, do you have to use a different strategy for basically breaking up code to be able to find the relevant chunks versus something like an illegal document? So far, we have not done anything visually different across these different types of documents. And based on the customer feedback so far, things like code and working fine. We see that in some cases where there are graphs or tables, we have sometimes seen that the chunking strategy, the default chunking strategy doesn't work.

We are working on techniques to make sure we represent this data in a more structured way and we can provide it to the model without breaking that structured context. But yeah, that is something being in the works. Yeah, and in a lot of cases, it is about chunking. But if you look at the structured data that is not just plain text, like parsing tables and graphs, that's where we see some regressions in terms of quality. But the way we address this is most of the different chunking, it's mostly through pre-processing the data, making sure that the column sense grows and the table are aligned well when the data is represented to the model is text.

So this kind of pre-processing is more important to get the quality right. And I guess, and also going back to what you were saying, 80% embedding model. So there's also this reliance on, I guess, if you use the embedding model that truly represent the semantics of what it is that you're creating the embedding from, then you're going to get a higher quality search result. Yes. That's the fact that your overlapping chunks would be gritty multiple chunks which have the overlapping parts and then we can then kind of recreate the whole context that is needed.

Right. So you're checking away the vector database and the indexing that you're doing. But how does this work with updates? I think that's historically been a challenge. Like if I process a document and then later that document changes, it may be a website is even a better example where a website's going to change from time to time.

But if I index that particular page and then I need to re-index it, how does that kind of update process work? There are two parts to this update. One is basically you kind of calling our API to ingest those documents. So we try to make sure that we are highly penalized in terms of our ingestion latency. So pretty much can penalize at a chunk level and ensure that all of those are ingested into the database.

And then Google has this panel, which is also exposed externally as a cloud spanner, which provides very strong consistency guarantees. So once you pretty much write the data, it's almost instantaneously available to be indexed. And we leverage that capability of spanner to make sure that we can pretty much read our rights as soon as they are available. That's really reduces the delay in reading the indexes and reading the embeddings. Do you have the, like if I've already indexed a particular page though or a document and then I'm re-indexing it, do I have to blow away the initial indexing indexes in order to re-index it?

Or is there essentially the equivalent of an upser in the vector world? So essentially you have the purpose. You can add your new document to that corpus, which would just mean that the new chunks are indexed the rest of the index remains as it is. In our world, you're not updating the document, you are inserting a new version of the document and you're chunking that and indexing. But if the old version is there, do you run into this potential risk that when you're pulling back relevant chunks, you could pull back relevant chunks that are no longer actually relevant because the fundamentals of the document is changed.

Yeah. So that ability we provide to the developers in terms of the corpus management of the document management case. So if they want, they could delete the earlier document. But from our perspective, it's difficult for us to figure out whether it's the new version of the same document. We are not doing data diff, I'd argue, it's up to the developers to remove the old content, everything that's not really limited.

And then is the search that's going on? Is it purely vector-based? Is there a hybrid element to this? Right now, it's purely semantic search, which is vector-based. We have had some requests of users wanting a keyword-based search and that is something that's happening to the roadmap.

Given the indexing capabilities that Spanner offers, we think it's like a natural extension to the offering and yet something which should not add to much complexity to our system. We also look at the GraphRAC systems in the past, but for now, to me, it feels a bit more complex called the project that we're trying to build, so we haven't found the right way to simply integrate it into the system yet. Yeah, I mean, I think that you see a lot in these more complex, right, pipeline scenarios where they're using a combination of vector search, there might be a knowledge graph or a topology or something like that to also ground the results and some semantic understanding. Is that something that you see as a future direction for this or would it be more, you would use this in combination perhaps with a separate system that would handle that piece of it?

So far what we saw from our customers is that the current setup is working well for them. And I think we will not over-complicate it just yet to answer your question directly. I feel that we better have two separate systems that can complement each other. And then we can also use the same system that we use to implement the same system. And then we can also use the same system that we use to implement both the search and use.

In a more complex use cases, I would say we also have, I mentioned the Vertex RAC system, which is built on both of the, it's not quite JAMON API, but it's a very similar JAMON API inside the Vertex. So for anything that requires a lot more complex configuration, maybe swapping out the databases for any business system, we can always guide customers to use more complex solutions they really need. And we can focus on the simplicity and the getting started. Okay. How do citations work?

How do you map, I guess, sort of the generated token back to the specific source chunk? The models are trained to cite the responses. So when they generate the responses, they actually cite every sentence that they have used the original code was to generate from. And then it's just a matter of course processing that response, removing those citations and adding that separately as grounding data. So essentially, it's model generating citations to the data that they refer to.

Yeah. So the model is trained to, essentially, figure out or to provide a reference back to where that text or what the source text was. And then you have to map that source text, I guess, back to the database chunk in the original source in order to inject the link or something like that that refers to the citation. Is that right? Yeah.

So basically, when the flow is something like this, when the model realizes that it needs to use file search, it will limit the query that I want this query to be answered by the file search. You run the query and you give the responses. Each response in some sense is indexed uniquely. So the model is receiving five chunks of data. It knows that each of them is a different index and this index can be equal to an as well.

So now in the model response, it kind of cites the exact unique index using which we can kind of figure out which chunk it was referring to and then figure out which document it was part of and add more data about that. Okay. So I'll post that talks about the product in that you cover there's a company beam, which is a AI driven game generation platform that's using this. Can you talk a little bit about how are they using this product in there? I guess it's a solve problems in their world.

I think they're used cases pretty neat and simple at the same time. So they have a lot of new developers coming to the platform for one to build games with the AI and they don't necessarily experience developers. They are mostly learning and AI helps beam to educate and helps those developers to create their first game. So the way the audience and file search is they have a huge code base that is their engine plus the documentation on top of that that is talking about like how each component is used, how the animations are happening, how scripts are implemented, et cetera, et cetera. It's a rather big data set.

So what they do is they put it all into the file search, the index and whenever the user starts experimenting with the agent and the agents that supports it, they will naturally ask questions how to do specific things and through file search, they can very quickly pull all the relevant documentation into the context and actually present to the developer that hey, you probably want to use this module. Here is how it works. Here is the whole documentation and they've been able to close this education look for their customers to receive free data. What's the performance on the retrieval look like? Performance in terms of retrieval quality or latency?

Let's start with latency. Latency is somewhat in line with the module latency couple of seconds called retrieval. In terms of quality, it will depend on the use case. If I recall correctly, we saw up to like 85% depending on the use case of the retrieval, correct hits in terms of the bulk events, redrift. As a user of this, given that, I mean any right, it's going to be very difficult to get like 100% accuracy on retired documents.

But what are some of the things that approaches people take to help increase the accuracy? I think there would be like a few things. One would be naturally be the emitting model that you want to talk about and kind of quality importance. The second is your retrieval strategy. Like sometimes you would want to optimize quality for latency, whether you want to kind of go through your entire database, find all relevant chunks or kind of figure out the first few relevant chunks and give it to the model.

So that would kind of be the other aspect on like trading off latency versus quality. And third, I think is just the model training on triggering the search only when relevant and also not hallucinating the answers. Those are kind of possible to file search. Those apply to any tool that we have to in Gemini with. But I would say those are kind of the three aspects.

The emitting quality or the tree quality and just the model quality which probably is offered most importantly. Yeah, that's mostly an hour and that's what we are working on in terms of improving the quality for developers. What I saw is some developers actually implemented the post processing. So they would implement file search calls in a separate agent or separate flow and they will do filtering on top of the return results. So they will call Gemini one more time.

They will have a prompt that is doing the verification of the results in comparison to the context that the model already has and they will call out the results that don't really fit the context on the conversation and improve the quality of the algorithm that way. Is there value in using a re-rank or model? Have you found in your own experiments that it actually improves? It's worth the investment of introducing something to re-rank the results from the vector search. Not so much.

In fact, I mean that just adds more complexity and if you extrapolate the question that we were talking about a bit earlier about whether even we do need drag, I think if you take that logic and apply it here that once you give the relevant chunks and as long as your context is not going up too much, I think letting the model figure out what is relevant probably is better. Yeah, in terms of if you are removing too many chunks then we have some threshold on what is the quality score of this chunk. Then we have some threshold below which we don't return those to the model but that's not like re-ranking between chunks is just like a vanilla cut off beyond which we don't get any more chunks. But between that we have not seen any advantage of providing a ranked order to the model.

What about in terms of people who look at fine tuning and bending models for specific use cases, has there been recent results around actually improving retrieval or is it again just sort of over-complicating the whole process? We have a general recommendation in GDM and I think we made this a year or so back that people shouldn't do fine tuning in most of the cases. The speed of progress of the models is so much faster than what individual smaller labs can do in terms of fine tuning. That is almost irrelevant and by the time you actually have a fine tune model and it will probably perform better for a use case for a month or two. We're going to have the next 003 embedding model if it's going to be better.

It was the board of like 50% of all the benchmarks and fine tuning won't be that relevant. With that said, we do see people using fine tuning in specific use cases. I think it does make sense if your use case is very, very niche and you have all the very particular data set which you don't expect Google or anyone else to pay attention to anytime in the future, that may yield some good results. But as I said so far what we've seen is fine tuning becomes relevant within six months. Yeah, I think that's fair.

I've found a similar result working with Business on My End. I think that one of the challenges as well is that if you do go through the process of fine tuning then, even if you are getting better results for six months or whatever, then a new model comes along. You've adjusted the weight so how do you apply that to a new version of the model? Yeah, you need to start over. That's pretty much wrong scratch.

You have to find them all the way. Yeah, it gets kind of expensive. As the models improved, you think that a lot of the things that we've historically done with RAG to try to drive out performance ends up, basically we don't have to make things quite as complicated because we can rely on better performance from the model and the model is kind of absorbing a lot of the complexity. Yeah, absolutely. Do you think so?

We did see an amazing progress for Gemini models in the last year and not just Gemini models. You look across the board and throw up the ideas. Great work in improving their text LLMs. First of all, these improvements do convert into embeddings models as well and separately we are working on improving the embeddings model more and more and we can see in the next year or two we can see significant improvements in terms of virtual quality in terms of use case complexity that those models can handle. So I do believe that a lot of this additional configuration that is happening around those models will go away and people will be able to just embed the thing, hit the search and get the results that are really relevant to you.

What are some of the things that have happened over the last year or so that have made the embedding models better? What are the particular innovations that have happened there to really drive up performance? I mean, we have added the multi-modal embedding support now. This would really improve the quality of understanding of things beyond text. So that is one thing and I think it's in public preview right now.

So we are hoping to do a deal on for that. The other thing which kind of you launched, I think in the last version of our embedding model or the one before that I don't remember is we started representing embeddings as this multi-order presentation which basically means the embedding vector that is generated. The front part of that vector has more context about the thing being emitted in the latter part which makes it very easy for the end user to just truncate the embedding. So in case like the embedding is a 3k dimension embedding of the embedding vector and you don't want to store as much size, you could just truncate it at any point and it would still give you an accurate enough representation of the entity. So some of those things have been really helpful and some of those we can actually explore like we were talking about the norms that we could give to the user.

That would be another knob in future. So we can actually use the user to reduce the size of their storage by using a truncated embedding instead of the full embedding at the cost of some quality. So based on their use case, users can choose to pick one of the two knobs. What do you see as some of the like hard problems in the space that are yet to be solved when it comes to bragging particular? I think even if I don't but like multi-order we are certain, I'm sure we'll kind of add on more capabilities on the multi-order site.

That is one thing. We talked about junking. That's still an area I feel we can get more benefit out of by kind of capturing the structure better in certain kind of use cases. The multi-lingual or like the internationalization that is another aspect, I feel we are getting great at solving English related queries. But there are certain languages where certainly we could do more.

And as the user base expands to countries across the world, we have more of these internationalization use cases. So that is another aspect where I feel we can certainly improve. Yeah, just in general, I think getting the quality higher hit rates, better retrain always something that we always pursue. Multi-modo is very interesting aspect. Text is working great for a lot of use cases, but there is a lot more multi-modal use cases that people are thinking of right now.

Looking for images, looking for video opens up a lot more consumer products that can be built on top of that. The file search and any record drill here is even more beneficial than full-tax because of the size of the data that you are feeding into the model. So if you can reuse that as much as possible to file search, that'd be very interesting. One thing, just bringing us back to the file search tool. In terms of people who have already invested in a particular stack to do reg, whether it's a combination of vector database, a particular framework, they have their chunky shawty like, what is it that they need to do if they wanted to migrate essentially over to the file search tool approach?

Well, migration itself I hope is fairly easy and straightforward. You are both your data. But the reality is, I think, what I would recommend them to start with is probably use the in-body model that we provide, it is available as a standalone service. So they have their own pipeline and they want to run the e-bels and experiments with the Gemini infrastructure. I would recommend using the in-body model first with part of their data just comparing the results.

And the next step would be using the file search, holding a small portion of their database and just running e-bels comparing both the systems. And then what is the status of a file search tool in terms of its availability? Is this early access, is this preview? What can you share around the timelines where people can start to get hands on this more generally? The model search is actually generally available for our 2.5 model family and recently our 3 model family.

So 2.5 models are in GA. So it's both models and the two combination are, and generally available. Flash 3 and Pro 3 models are still in preview, but file searches as an API is generally available there as well. Okay. And then what is Nax besides moving all the stuff to getting it in the hands of the minute more users?

Like what can you share about some of the things that you're thinking in terms of additional problems with TAC or things that you want to continue to make investments around making the product really, really easy to use? Yeah. So as we mentioned, multi-mode is the multi-mode of what is the big push. So we're doing, we want to invest into a better understanding of structured data and we keep collecting this examples from our developers in terms of the tables and graphs and whatnot, the data trying to process. So I think that's going to improve the quality and the ability of this a lot.

And then latency ends being able to work with a much bigger data sets. We do limit at one terabyte right now for the highest tier, but the latency go down quite a bit if you start consuming all of the, what else do we want to invest in that as well and improve the return of latency? Is that one terabyte of total storage? Is that right? Yes.

That's definitely one terabyte of total storage of course. All of your fast source. Is there a limitation around the size of single file that can be processed other than I guess it needs to be smaller than terabyte? It's 100 MB right now. So that is the, we have kept on the site and making sure that the retrieval latencies are kind of acceptable and in the good range.

We recommend users to keep their individual Quattvers to about 20 GB. So their total data across Quattvers is going to be 1 GB. But each Quattvers or each file search store as we call it should be the element of 20 GB. And then at the quality time you can provide multiple of these file search store IDs. So we can find out who is going to use in parallel, but the size of individual file search store performs good to the limit of 20 GB.

Okay. So I don't want to play with this. Like how do I get started? The simplest way I think would be to go to the iStudio and play with the file search app list. I think the link is available in the blog post that we published.

And the other way is to start hitting the Gemini API. Okay. Great. We have a couple of examples that make it really easy for somebody who is starting around just uploading data using the app load API and hit the Gemini API. Oh, and our white coding environment in the iStudio also fully supports the file search so he can just prompt the model to generate the code that you just file search and it will do it for you.

Okay. Well, even easier. Is there anything else you would like to share as we start to wrap up? I just want to say that it's been really exciting to see the adoption that we're getting for file search. We actually received quite a lot of great feedback from developers and quite a lot of excitement and it's been really nice to see how this works for their use cases.

Fantastic. Well, Ivan and Amash, thank you so much for being here. Thank you for having us. Cheers.

Frequently asked questions

How long is this episode of Software Engineering Daily?

This episode is 40 minutes long.

When was this Software Engineering Daily episode published?

This episode was published on March 12, 2026.

Is there a transcript available for this episode?

Yes, a full transcript is available for this episode. You can read the complete transcript on the episode page.

Can I download this Software Engineering Daily episode?

Yes. Use the download control on the episode player to save the publisher-provided media file.