I Stopped Using Grep and My Agent Got 10x Faster

I Stopped Using Grep and My Agent Got 10x Faster ![rw-book-cover](https://img.youtube.com/vi/gPeWb4_DMok/maxresdefault.jpg) 🔗 **Source:** [I Stopped Using Grep and My Agent Got 10x Faster](https://www.youtube.com/watch?v=gPeWb4_DMok) > [!note]+ Document Notes > tags: #ai-coding-agents #vector-databases #mcp-servers #code-indexing #claude-context #zilliz > author: AI Jason > source: YouTube > reference: https://www.youtube.com/watch?v=gPeWb4_DMok > date created: 2024-12-19 10:30 > > # 🏷️ Title: I Stopped Using Grep and My Agent Got 10x Faster >  ## 🧰 Action Inbox - [H1] Test Claude Context on average-size codebases (20-30k lines) — better cost/benefit ratio than large repos #ai-coding-agents - [H2] Set up Zilliz Cloud serverless cluster for production use — avoid free tier timeout issues #vector-databases - [H3] Compare MCP server performance against traditional grep/glob searches — measure tokens and response time #mcp-servers ## 🧭 Table of Contents - [[#📝 Summary]] - [[#📖 Main Content]] - [[#🗒️ Notes]] - [[#📚 References]] - [[#🗣️ Paraphrase]] - [[#📰 Newsletter]] - [[#✅ Action Items]] - [[#🧪 Hypotheses]] - [[#📊 Methodology]] - [[#❓ Questions]] - [[#🔮 Future Research]] - [[#💡 Implications]] - [[#🧠 Learning Styles Assessment]] - [[#📊 Accessibility Assessment]] - [[#🌍 DEIB Assessment]] - [[#✅ Logical Validity]] - [[#🛡️ DARVO Analysis]] - [[#🎯 Conclusion]] ### 🔗 References - [Claude Context MCP Server](https://github.com/zilliztech/claude-context) - [Zilliz Cloud Platform](https://cloud.zilliz.com/) ## 📝 Summary - Claude Context MCP plugin indexes entire codebases into vector databases, enabling AI agents to find relevant code faster than grep/glob searches - The system uses Tree-sitter parsing, Merkle DAG hashing, and hybrid search (semantic vectors + keyword matching) to achieve 40% context reduction - Testing on VS Code's 1.5M line codebase showed mixed results: better detail and accuracy but not always faster than traditional methods - Setup requires Zilliz Cloud account and OpenAI API for embeddings, with costs ranging from cents for small repos to ~$1 for massive codebases - Most effective for average-size codebases (20-30k lines) where indexing is quick and performance gains are clear ## 📖 Main Content Claude Context is an MCP (Model Context Protocol) server developed by Zilliz that transforms how AI coding agents search through codebases. Instead of relying on grep or glob pattern matching, it creates a searchable vector database of your entire codebase. The system employs three sophisticated techniques: Tree-sitter parsing to create semantic chunks of functions and classes across nine programming languages, Merkle DAG hashing for incremental indexing (only re-processing changed files), and hybrid search combining vector similarity with BM25 keyword matching. Testing revealed nuanced performance characteristics. On VS Code's massive 1.5 million line codebase, Claude Context provided significantly more detailed and contextual responses but wasn't consistently faster than traditional methods. For broad architectural questions, it excelled at providing structured, comprehensive overviews with specific file references and line numbers. The cost structure involves both Zilliz Cloud hosting (serverless plans recommended over free tier) and OpenAI embedding fees. A 23,000-line codebase cost about 1 cent to index, while VS Code's full repository required $1.06 in embedding costs. ## 🗒️ Notes #### ⏱️ [00:00](https://youtu.be/gPeWb4_DMok?t=0) — [H1] Claude Context Overview - Key idea: MCP plugin indexes entire codebase into vector database for faster AI agent searches - Evidence: "uses 40% less context" and eliminates "guessing using grep or glob" #### ⏱️ [01:15](https://youtu.be/gPeWb4_DMok?t=75) — [H2] Technical Architecture - Key idea: Three-layer system with Tree-sitter parsing, Merkle DAG hashing, and hybrid search - Evidence: "supports nine languages including TypeScript, Python, Rust, and Go" #### ⏱️ [02:30](https://youtu.be/gPeWb4_DMok?t=150) — [H2] Hybrid Search Implementation - Key idea: Combines semantic vector search with BM25 keyword matching for better accuracy - Evidence: "results in an up to 40% context reduction, which is a lot for large code bases" #### ⏱️ [03:45](https://youtu.be/gPeWb4_DMok?t=225) — [H3] Setup Requirements - Key idea: Requires Zilliz Cloud account and OpenAI API key even when using Claude - Evidence: "I did try to use the free one first, but I kept on getting timeout issues" #### ⏱️ [05:00](https://youtu.be/gPeWb4_DMok?t=300) — [H2] Indexing Performance - Key idea: Initial indexing takes significant time for large codebases - Evidence: "after about 50 minutes, the indexing is complete" for VS Code's 1.5M lines #### ⏱️ [06:30](https://youtu.be/gPeWb4_DMok?t=390) — [H3] Cost Analysis - Key idea: Embedding costs scale with codebase size - Evidence: "23,000 lines of code has about 1,000 lines of entries" and "we've gone from 1 cent to $1.06" #### ⏱️ [07:15](https://youtu.be/gPeWb4_DMok?t=435) — [H2] Speed Comparison Test 1 - Key idea: Simple queries don't always favor Claude Context - Evidence: "using just regular GLM is a lot faster" at 14 seconds vs 19 seconds #### ⏱️ [08:30](https://youtu.be/gPeWb4_DMok?t=510) — [H2] Detailed Query Performance - Key idea: Claude Context excels at providing comprehensive code context and references - Evidence: "gives way more information showing the code and other files related to opening the editor" #### ⏱️ [10:00](https://youtu.be/gPeWb4_DMok?t=600) — [H1] Architectural Analysis Strength - Key idea: Provides structured, detailed architectural overviews with specific file references - Evidence: "giving the layered architecture and even some information about the Electron app and the processes" #### ⏱️ [11:45](https://youtu.be/gPeWb4_DMok?t=705) — [H2] Follow-up Query Excellence - Key idea: Excels at detailed follow-up questions with comprehensive file mapping - Evidence: "boot sequence and then phase one... app.ts line 185, and we could keep going on and on" #### ⏱️ [13:00](https://youtu.be/gPeWb4_DMok?t=780) — [H3] Traditional Method Limitations - Key idea: Non-MCP approaches use multiple sub-agents and more time for similar results - Evidence: "after about 5 minutes Open Code responds... but this isn't as much as what Claude Context provided" #### ⏱️ [14:30](https://youtu.be/gPeWb4_DMok?t=870) — [H1] Optimal Use Cases - Key idea: Most effective for average-size codebases rather than massive repositories - Evidence: "for average-size code bases, so 20 to 30,000 lines of code, the indexing time is really quick" #### ⏱️ [15:45](https://youtu.be/gPeWb4_DMok?t=945) — [H2] Practical Adoption Decision - Key idea: Worth adopting despite setup complexity for regular open-source code exploration - Evidence: "As someone who regularly goes through open-source code bases and asks questions, I think this is a tool I'm going to be using a lot more" ## 📚 References - [Zilliz Cloud](https://cloud.zilliz.com/) - [Milvus Vector Database](https://milvus.io/) - [Tree-sitter Parser](https://tree-sitter.github.io/) - [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) ## 🗣️ Paraphrase - Claude Context creates searchable vector databases of codebases, enabling AI agents to find relevant code through semantic understanding rather than text pattern matching - The system uses advanced parsing and hashing techniques to efficiently index code and only update changed files, combined with hybrid search for better accuracy - Performance testing shows Claude Context provides superior detail and context for complex queries but isn't universally faster, with sweet spot being medium-sized codebases ## 📰 Newsletter **AI Coding Gets Smarter with Vector-Powered Code Search** Claude Context is revolutionizing how AI coding agents understand and navigate codebases. Instead of hoping grep finds the right files, this MCP server creates a searchable vector database of your entire project. **Key Benefits:** - 40% reduction in context usage through semantic search - Hybrid approach combining vectors with keyword matching - Incremental indexing that only processes changed files - Works with any MCP-compatible AI agent **Perfect For:** Teams working with medium-sized codebases (20-30k lines) who want their AI assistants to provide more contextual, accurate code suggestions and architectural insights. **Getting Started:** Requires Zilliz Cloud account and supports nine programming languages including TypeScript, Python, and Rust. Resources: [Claude Context GitHub](https://github.com/zilliztech/claude-context), [Zilliz Cloud](https://cloud.zilliz.com/), [MCP Documentation](https://modelcontextprotocol.io/) ## ✅ Action Items #### DevRel - Developer advocacy: Create demos showing Claude Context vs traditional grep performance on real projects - Education: Workshop on MCP server setup and vector database concepts for coding agents - Developer experience: Document optimal codebase sizes and cost expectations - Developer marketing: Case studies with popular open-source repositories - Community management: Gather feedback on embedding costs and indexing performance #### OSPO - Software Inventory: Evaluate Claude Context for internal code discovery and documentation - Developer Support: Training on vector-based code search vs traditional tooling - Community Engagement: Assess impact on open-source contribution workflows - Strategic Alignment: KPIs for AI-assisted code comprehension and developer productivity #### Community - Maintainers: Templates for setting up Claude Context on popular repository structures - Contributors: Onboarding guides using AI-assisted code exploration - Ecosystem: Cross-project coordination on MCP server adoption patterns #### WordPress - Core: Evaluate Claude Context for WordPress Core codebase navigation and contribution onboarding - Core Performance: Test vector search impact on identifying performance-critical code paths - Core Program Team: Assess MCP integration for cross-team code coordination - Documentation: Use Claude Context for generating contextual code examples in DevHub - Plugins: Security review assistance through better code context understanding - Meta: Evaluate for .org codebase exploration and contributor onboarding ## 🧪 Hypotheses - Vector-based code search provides superior context for architectural understanding compared to text-based search methods - MCP servers will become standard infrastructure for AI coding agents across development environments - Hybrid search approaches (semantic + keyword) outperform pure vector or pure text search for code discovery - Cost-effectiveness of vector code indexing improves significantly for repositories between 20k-100k lines ### 📊 Methodology - Comparative study measuring response quality, token usage, and time-to-answer across different codebase sizes - A/B testing with developers using Claude Context vs traditional search methods for code comprehension tasks - Cost analysis tracking embedding expenses vs productivity gains across various project scales ### ❓ Questions - How does Claude Context performance scale with different programming languages and code complexity? - What's the optimal balance between local vector storage and cloud-based indexing for enterprise adoption? - How might vector-based code search evolve to include runtime behavior and test coverage information? ### 🔮 Future Research - Integration patterns for MCP servers in enterprise development environments - Hybrid approaches combining static analysis with vector-based semantic search - Real-time vector index updates for active development workflows ### 💡 Implications - Practice: Developers may shift from grep-based code exploration to vector-semantic approaches - Policy: Engineering teams need guidelines for AI-assisted code discovery and embedding data privacy - Security: Vector databases containing code embeddings require secure handling and access controls - Education: Developer training must include vector database concepts and MCP server architecture - Funding: Development tool budgets should account for vector database hosting and embedding API costs ### 🧠 Learning Styles Assessment Reading level estimate: 12th Grade (technical content with specialized terminology) #### 👀 Visual learners - Present: Code comparisons, performance timing displays, cluster dashboard screenshots - Improve: Architecture diagrams showing Tree-sitter → Merkle DAG → Vector DB flow, search result visualizations #### 🔊 Aural learners - Present: Video demonstration with narrated setup and testing process - Improve: Audio summary explaining vector search concepts and cost trade-offs #### 🗣️ Verbal learners - Present: Clear explanations of technical terms like "Merkle DAG" and "BM25" - Improve: More analogies comparing vector search to traditional file searching #### 🧩 Kinesthetic learners - Present: Step-by-step setup instructions, live coding demonstrations - Improve: Hands-on checklist for evaluating Claude Context on different codebase sizes #### 🧠 Logical learners - Present: Performance comparisons with specific timing and token usage data - Improve: Decision matrix for when to use Claude Context vs traditional search methods #### 🧑‍🤝‍🧑 Social learners - Present: Discussion of community adoption and developer experiences - Improve: Forum discussions about MCP server best practices and cost optimization #### 🧘‍♀️ Solitary learners - Present: Individual testing methodology and personal evaluation criteria - Improve: Self-assessment questions for determining optimal use cases #### 🌿 Naturalistic learners - Present: Ecosystem thinking about MCP servers and AI agent environments - Improve: Connections to broader patterns in developer tool evolution ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Descriptive headings and structured content flow - Improve: Alt text for code screenshots and performance comparison visuals #### Keyboard navigation - Present: Standard video player controls accessible via keyboard - Improve: Timestamped transcripts with keyboard-navigable sections #### Contrast and readability - Present: High contrast text in video overlays and code examples - Improve: Ensure code syntax highlighting maintains sufficient contrast ratios #### Text resizing and reflow - Present: Responsive text layout in description and comments - Improve: Ensure code examples remain readable at 200% zoom #### Media and captions - Present: Full transcript provided for accessibility - Improve: Time-synchronized captions in video player #### Forms and interactions - Present: Clear video controls and chapter navigation - Improve: Keyboard shortcuts for jumping between demonstration sections #### Standards reference - Meets WCAG 2.2 AA for text content; video content needs caption timing improvements ### 🌍 DEIB Assessment #### Cultural breadth - Present: Focus on universally applicable development tools and practices - Improve: Examples from diverse programming communities and languages #### Inclusive language - Present: Technical language appropriate for developer audience - Improve: Define specialized terms like "MCP" and "vector embeddings" for broader accessibility #### Neurodiversity support - Present: Structured content with clear section breaks and logical flow - Improve: Consistent heading frequency and summary sections for complex topics #### Representation - Present: Focus on technical content rather than individual representation - Improve: Include diverse developer perspectives on tool adoption costs and benefits #### Psychological safety - Present: Objective technical evaluation without judgment of different approaches - Improve: Acknowledge that different solutions work for different team contexts ### ✅ Logical Validity #### Strong reasoning - Deductive strength: Strong logical flow from vector search principles to performance outcomes - Inductive strength: Good generalization from specific VS Code testing to broader codebase patterns - Causal reasoning: Clear causal links between indexing approach and search performance - Analogical strength: Effective comparisons between traditional grep and vector-based search #### Fallacies - Hasty generalization: Concluding optimal use for "average-size codebases" from limited testing, needs broader validation - False dilemma: Presenting --- ## Full Transcript [00:00] So, there's this MCP plugin called [00:03] Claude Context that indexes your entire [00:05] code base into a vector database, [00:07] meaning your coding agent can get the [00:09] exact code it needs quickly without [00:11] [music] guessing using grep or glob and [00:13] hoping it finds the right file. It even [00:15] passes your code with ASTs and uses a [00:18] hybrid search approach combining [00:20] semantic vectors with keyword matching, [00:22] which ends up using 40% less context. [00:24] But, it does need a Zilliz Cloud account [00:26] and an OpenAI key for embeddings even if [00:29] you use Claude Code. So, is the extra [00:31] effort and cost worth the token savings? [00:33] Hit subscribe and let's find out. [00:39] Okay, so Claude Context, not sure about [00:41] the name, is made by Zilliz, which is a [00:43] company created by the founders of [00:45] Milvus, a very performant vector [00:47] database. It connects to your agent by [00:49] MCP, so this means it can work with any [00:51] agent harness and not just Claude Code. [00:53] But, it does three pretty complex things [00:56] to make your code easily findable. [00:58] First, it uses Tree-sitter to pass [01:00] through all of the code creating chunks [01:02] of functions and classes, and this [01:04] supports nine languages including [01:06] TypeScript, Python, Rust, and Go. Then, [01:08] it uses a custom Merkle DAG to hash each [01:11] file with JSON snapshots, meaning it [01:14] only re-indexes the files that have [01:16] changed and not the whole code base. And [01:18] then, when you actually want to search [01:19] through the code, it does two different [01:21] types of searches at the same time. A [01:23] vector search to find the semantic [01:26] meaning of the code and a BM25 index [01:29] search for exact keyword matching. This [01:31] all results in an up to 40% context [01:34] reduction, which is a lot for large code [01:36] bases. In fact, let's see it in action [01:38] by testing it against the VS Code code [01:41] base, which has around 1.5 million lines [01:44] of code. So, inside the current VS Code [01:46] repo, I'm going to be using Open Code [01:48] with GLM-5 Turbo because I don't want to [01:50] burn through my Claude Pro weekly [01:52] limits. And in order to get the MCP [01:55] server set up, which you can see over [01:56] here, I've already added the relevant [01:58] information to my Open Code JSON file. [02:01] And for this information over here, you [02:03] could run Milvus locally, but I've used [02:05] Zilliz Cloud. So, I've got my API key [02:07] from over here and I created a cluster, [02:10] so this is an AWS cluster, and got the [02:13] public endpoint from here. Now, while [02:15] we're on clusters, I did try to use the [02:17] free one first, but I kept on getting [02:19] timeout issues. So, I have to get a [02:21] serverless one, which does cost money, [02:23] but did work a lot better. Now, once you [02:25] have set up the MCP server, make sure [02:27] you're running a version of Node below [02:29] 24, but above or equal to 20. I'm [02:31] currently using version 22 just for this [02:33] project, and that will give you access [02:35] to four MCP tools: index code, search [02:37] code, clear index, and get index status. [02:40] Now, the first thing you have to do is [02:41] index the code base. And we can do that [02:43] with this prompt. But, before we hit [02:44] enter, let's take a look at how much [02:46] money we've already spent on embeddings [02:48] from OpenAI, which is just 1 cent and [02:50] was for me testing a 23,000 line code [02:53] base. We can also see in our cluster we [02:55] already have information from the code [02:56] base that was indexed. So, now if we [02:58] index this code base, it does take some [03:00] time and starts the indexing in the [03:02] background. At this point, I don't [03:04] recommend doing any searches. Now, [03:05] because this is a large code base, it [03:07] will take a while to index, so I'll come [03:09] back later when the indexing is done. [03:11] And after about 50 minutes, the indexing [03:13] is complete. And we can see we have a [03:15] new chunk in our cluster with over [03:17] 223,000 [03:19] loaded entries. And for reference, the [03:22] code that I was testing with that had [03:24] 23,000 lines of code has about 1,000 [03:28] lines of entries and took less than 1 [03:31] minute to index. And with our OpenAI [03:32] usage, we've gone from 1 cent to $1.06, [03:36] which is a lot, but I don't imagine [03:38] going through 1.5 million lines of code [03:41] is something people will do regularly. [03:43] Okay, let's see how fast it is to make a [03:44] search. Here we have one instance of [03:46] Open Code using the Claude Context MCP [03:48] server, and here we have one with no MCP [03:51] server. So, it'll be using the regular [03:53] grep and glob tools to search through [03:55] the code. And we'll give it a prompt of [03:57] use Claude Context to find the entry [03:59] point of when this project starts up. [04:01] Let's see how long this takes. Okay, so [04:03] it's using the index tool, and now it's [04:04] using the search tool, and the whole [04:06] thing took about 19 seconds to search [04:08] through this whole project and find the [04:10] main.ts file. And now we're going to [04:12] give this Open Code a similar prompt, [04:14] and it finds a response in 14 seconds. [04:16] So, it's like for this query, using just [04:18] regular GLM is a lot faster. Let's start [04:20] a new session, and then I'm going to [04:22] give it a new prompt of what function [04:23] opens a new untitled document. This one [04:26] took a bit longer at 40 seconds and [04:28] found the main function with a line [04:30] number and used about 23K tokens. And [04:32] the other instance did it in 12 seconds [04:34] and used 18K tokens, but it looks like [04:37] it found a different file. In fact, [04:39] Claude Context gives way more [04:40] information showing the code and other [04:43] files related to opening the editor. So, [04:45] I'm going to ask them both to show me [04:46] the exact code, and at this point Claude [04:48] Context responds in 23 seconds with the [04:51] code, and the non-Claude Context Open [04:53] Code responds in 49 seconds, almost [04:55] double the amount of time. And it gives [04:57] you the exact same code as Claude [04:58] Context did, which gives me an idea. I'm [05:00] going to give it a more broad [05:02] generalized prompt of look through the [05:03] code and tell me how this project works. [05:06] Claude Context finishes in 49 seconds [05:08] using 41K tokens, and the other instance [05:11] finishes faster and uses less tokens. [05:13] But, if we have a look at the output [05:15] produced, we can see there's much more [05:16] detail from Claude Context giving the [05:18] layered architecture and even some [05:20] information about the Electron app and [05:22] the processes it uses. And the [05:23] non-Claude Context option does also give [05:26] some architectural information, but it's [05:28] not as detailed as the other one. In [05:30] fact, I know it doesn't look like it, [05:31] but I would say Claude Context is very [05:33] good at getting code information up [05:35] front quickly in lots of detail. I mean, [05:37] take a look at this. So, from this [05:39] prompt I asked a follow-up prompt to [05:41] tell me more information about the main [05:43] process in the Electron app, which it [05:45] stated up here. So, after I asked this [05:47] prompt, it took about 1 minute and 47 [05:51] seconds, but look at all that detail. [05:53] So, it started out with the boot [05:55] sequence and then phase one, so the [05:57] service creation and service [05:59] initialization. And we've got so much [06:01] more from phase two, the code [06:02] application app with all the references [06:04] to the relevant files. So, we've got [06:06] app.ts line 185, and we could keep going [06:09] on and on. Whereas, without Claude [06:10] Context, Open Code is still going [06:12] through all the files using multiple [06:15] sub-agents, and this is a bit deceiving [06:17] because we can't see exactly how many [06:19] tokens each sub-agent is using. But, if [06:22] we wait for a bit and come back, we can [06:23] see after about 5 minutes Open Code [06:26] responds with a lot of information about [06:28] the Electron process, but this isn't as [06:30] much as what Claude Context provided, [06:32] and it did take five times longer. Now, [06:35] yes, maybe if I used a smarter model [06:37] like Opus 4.7 with high effort, it would [06:40] get more information, but it would still [06:41] take a long time and use a lot of [06:43] tokens. And these are the kind of [06:45] differences, so 5 minutes and 1 minute, [06:47] that I was seeing when I was testing [06:48] before recording with the 23K line code [06:51] base. So, in the end, it's difficult to [06:52] say who is the clear winner. I mean, [06:55] Claude Context did always provide more [06:57] detail, but it wasn't always the fastest [06:59] and the most token efficient. And for [07:01] large code bases, it did take a very [07:03] long time to index. However, for [07:05] average-size code bases, so 20 to 30,000 [07:08] lines of code, the indexing time is [07:10] really quick, and the difference in [07:12] detail when it comes to results is very [07:14] apparent. In fact, I would say I would [07:16] much rather use Claude Context for [07:19] average-size code bases than use it on [07:21] large code bases. So, that's something [07:23] to think about. But, to be honest, this [07:24] is more of a great sales tool for Zilliz [07:26] because before using Claude Context, I [07:28] had never heard of them, and now they [07:30] have a new paying customer. But, even [07:32] though it did take a while to set up and [07:34] indexing large code bases took a very [07:36] long while. As someone who regularly [07:38] goes through open-source code bases and [07:41] asks questions, I think this is a tool [07:43] I'm going to be using a lot more. I [07:44] mean, for an average-size code base, the [07:46] serverless plan isn't too expensive as [07:49] the OpenAI embeddings don't cost too [07:51] much either. So, I'm happy to take the [07:52] hit. Speaking of data retrieval and AI, [07:55] if you want to learn how to build a [07:56] really good rag system from scratch that [07:59] actually works, then check out this [08:01] video from Andras. And if you're a Star [08:03] Wars fan, you're especially going to [08:04] like this video.  📄 **Full text:** ![[Full Document Contents/Articles/I Stopped Using Grep and My Agent Got 10x Faster.md|I Stopped Using Grep and My Agent Got 10x Faster by YouTube]] ## Highlights - number and used about 23K tokens. And the other instance did it in 12 seconds and used 18K tokens, but it looks like it found a different file. In fact, Claude Context gives way more information showing the code and other files related to opening the editor. So, I'm going to ask them both to show me the exact code, and at this point Claude Context responds in 23 seconds with the code, and the non-Claude Context Open Code responds in 49 seconds, almost double the amount of time. And it gives you the exact same code as Claude Context did, which gives me an idea. I'm ([View Highlight](https://read.readwise.io/read/01kq2r9sr60w568797y3pkrmzv)) - Tags: 👻 ai highlighted - have a new paying customer. But, even though it did take a while to set up and indexing large code bases took a very long while. As someone who regularly goes through open-source code bases and asks questions, I think this is a tool I'm going to be using a lot more. I mean, for an average-size code base, the serverless plan isn't too expensive as the OpenAI embeddings don't cost too much either. So, I'm happy to take the hit. Speaking of data retrieval and AI, if you want to learn how to build a really good rag system from scratch that actually works, then check out this ([View Highlight](https://read.readwise.io/read/01kq2r9ss6grvxe61pkp19va5m)) - Tags: 👻 ai highlighted