DEV Community: kevinrawal

I built NexRAG: a framework-agnostic RAG pipeline SDK.

kevinrawal — Sun, 05 Jul 2026 06:44:49 +0000

Over the past few months, while building RAG applications, I kept noticing the same pattern.

Every new project meant rebuilding the same pipeline from scratch:

choosing an embedding model
selecting a vector database
experimenting with chunking strategies
switching between LLMs
adding rerankers
integrating observability
evaluating responses
wiring it all together in code

The business logic changes across projects, but the underlying RAG architecture is largely the same. Yet every team ends up re-solving it, and optimization always gets pushed to "later."

So I built NexRAG — an open-source framework that lets you build production-ready RAG pipelines using simple YAML configuration instead of rewriting orchestration code every time. What used to take 3,000+ lines of custom code now takes roughly 300 lines to get a production-grade pipeline wired up.

With a few config changes, you can:

Swap LLM providers
Change embedding models
Try different chunking and retrieval strategies
Switch vector databases
Configure rerankers
Enable LLM-as-a-Judge evaluations
Add observability and evaluation metrics
Build custom components and plug them into the pipeline

The idea is simple: configuration over boilerplate.

Need something custom? Every component is extensible. Build your own retriever, embedder, chunker, vector store, or evaluator, and plug it in — no changes to the core framework required.

From day one, NexRAG is designed with production in mind — not just retrieval, but observability, evaluation, and security, which most AI projects only think about after something breaks.

🔗 NexRAG: https://lnkd.in/d4QRBZmb
🔗 Example project (Simple Policy Bot): https://lnkd.in/drgMSq4C

This is just the beginning. NexRAG is fully open source, and I'd love to collaborate with developers working in AI infrastructure, RAG, LLMOps, and production AI systems. Feedback, issues, feature requests, and contributions are all welcome.

Looking forward to building this together.

Master Git with Interactive Learning Platforms! 🚀

kevinrawal — Sat, 06 Jan 2024 04:29:58 +0000

Hey folks,

Are you looking to level up your Git version control skills? We've got you covered! Here are two awesome online platforms that offer interactive and engaging ways to enhance your Git proficiency:

LearnGitBranching:
LearnGitBranching is an interactive and visually appealing tool that allows you to practice Git branching, merging, rebasing, and more. Whether you're a beginner or looking to refine your skills, this platform provides an intuitive way to understand and experiment with Git commands. It's a great resource to solidify your understanding of Git workflows.

Git Exercises:
Git Exercises is another excellent platform to enhance your Git proficiency. With various exercises and challenges, it covers a wide range of Git concepts and scenarios. The hands-on nature of these exercises makes it a valuable resource for individual learners and teams aiming to improve their version control practices.

By actively engaging with these platforms, you can gain practical experience and boost your confidence in using Git effectively. Whether you're a developer, student, or simply curious about version control, these resources cater to various skill levels.

do share other helpful resources in the comments.
Happy coding! 🚀

TLE Tales: When Unordered_map Bites You

kevinrawal — Fri, 29 Dec 2023 14:58:05 +0000

Hey, fellow devs👋!

I just tackled a problem that taught me a valuable lesson about time complexity: always consider the worst-case scenario, even when average-case performance seems good ⚠️.

Here's the gist:

Problem: Find a subarray with a sum of zero.
Constraints
- Array size: 1 to 2*10^5
- Element range: 1 to 10^9
- Total sum of elements: ≤ 2*10^5

My initial approach:

Used unordered_map to store sums for efficient lookup.
Average-case time complexity: O(1) ✨
Worst-case time complexity of entire code: O(n) (this led to the TLE)

The TLE surprise:

Got a Time Limit Exceeded (TLE) verdict, specifically during lookup operations in the unordered_map.
Why? The worst-case lookup time in unordered_map can be linear O(n), so with the given constraint worst-case complexity of the program becomes O(n^2).

The solution:

Switched to map (ordered_map with worst-case complexity O(log n)):
- Now Worst-case time complexity of my code become: O(nlogn), O(n) to traverse the array and O(long) for lookup.
- Accepted solution!

Key takeaways:

just look at the complexity of ordered and unordered_map

This complexity tells you a lot about when to use which data structure, map stores the data in a sorted manner while unordered will not, here we do not need sorted data which's why in the first attempt I went with unordered_map but later I realized my mistake and correct it.

instead of 10^5 if the number of elements is 10^9 then our ordered_map will not work so,

Always analyze worst-case time complexity, especially when dealing with large inputs.
Don't rely solely on average-case performance.
Choose data structures wisely based on problem constraints and potential worst-case scenarios.

Happy coding!!

Quick Sort vs. Merge Sort: A Developer's Dilemma 🤔

kevinrawal — Sat, 23 Dec 2023 09:51:11 +0000

Let's delve into the intriguing realm of sorting algorithms and zoom in on the dynamic duo—Quick Sort and Merge Sort. 🚀✨

Quick Sort: The Swift Pathfinder 🏎️

Quick Sort is the speed demon of sorting algorithms. Its divide-and-conquer strategy, coupled with clever pivot selection, makes it incredibly efficient.

Use Cases:

Real-Time Processing: In scenarios like financial trading, where split-second decisions matter, Quick Sort's speed is a game-changer.
Large Datasets: When dealing with massive datasets, Quick Sort's average time complexity of O(n log n) shines, ensuring rapid data organization.

Worst Case Consideration:

Caveat Emptor: However, it's important to note the worst-case scenario. If the pivot selection consistently results in unbalanced partitions, Quick Sort can degrade to a quadratic time complexity (O(n^2)), making it less favorable for certain cases.

Merge Sort: The Consistent Performer 🔄

Merge Sort, on the other hand, takes a more laid-back approach. It's stable, reliable, and maintains a consistent performance.

Use Cases:

Stability Matters: When stability is crucial, as in applications where the relative order of equal elements must be preserved, Merge Sort comes to the forefront.
Predictable Performance: In scenarios where a consistent and predictable time complexity of O(n log n) is preferred over the fastest possible speed.

Choosing Wisely: Balancing Speed and Consistency ⚖️

As developers, the choice between Quick Sort and Merge Sort often boils down to the specific needs of the task at hand. Need blazing speed and can handle a bit of unpredictability? Quick Sort is your ally. Craving stability and a consistent performance profile? Merge Sort has your back. 🤝

Your Experiences?💬

Have you encountered situations where the choice between Quick Sort and Merge Sort made a significant impact on your project? Share your thoughts, experiences, and let's keep the conversation alive! 🚀✨

2023 Leetcode Rewind

kevinrawal — Thu, 21 Dec 2023 04:46:13 +0000

"2023 was a great year for my coding skills! Thanks to LeetCode
for helping me level up 🚀.