Forem: Swapnil Take

Retrieval-Augmented Generation (RAG) system using LangChain, ChromaDB, and local LLMs.

Swapnil Take — Fri, 20 Mar 2026 17:17:47 +0000

The Problem: The "Documentation Drain"

We’ve all been there: you need a specific sql syntax or a complex join optimization strategy, and you're stuck searching a 200-page PDF. Standard AI models like ChatGPT are great, but they don't know the specifics of your project's internal documentation.

The goal was to build a system that:

Reads the entire PDF.
Indexes it for instant retrieval.
Answers complex queries using a local model for privacy and speed.

The Tech Stack (2026 Edition)

To keep the project modern and efficient, I used a modular stack:
Language: Python 3.12+ managed by uv (the fastest package manager).
Orchestration: LangChain and LangChain-Classic for the RAG pipeline.
Vector Database: ChromaDB for persistent, local storage.
Models: Google Gemini 2.5 Flash (for heavy lifting) and Qwen 3: 0.6B-F16 (running locally via Docker).
Frontend: Streamlit for a clean, browser-based chat interface.

Implementation: Step-by-Step

1. Data Ingestion & Chunking
A 200-page PDF is too large for an LLM to "read" all at once. We broke the document into smaller, overlapping chunks using the RecursiveCharacterTextSplitter. This ensures that context (like a SQL statement that spans two pages) isn't cut in half.

Python text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=200) chunks = text_splitter.split_documents(raw_documents)

2. The Search Engine (Vectorization)

We converted these text chunks into mathematical vectors using Google’s Gemini Embeddings. These vectors are stored in a local ChromaDB folder. The beauty of this is persistence: once you index the document, you never have to do it again. You can simply "load" the database in milliseconds.

3. Going Local: Docker + Qwen 3

For maximum privacy and zero API costs, I integrated a local model. Using Docker Model Runner, I deployed Qwen 3 (0.6B). Even at a small parameter size, it handles SQL generation and technical explanations with impressive accuracy when grounded by the retrieved context.

4. The User Interface

While Jupyter Notebooks are great for development, they aren't for "users." I wrapped the entire logic in a Streamlit application. This converted the Python code into a professional web interface with a chat history, loading spinners, and source attribution (telling the user exactly which page of the PDF the answer came from).

Key Challenges Overcome

Rate Limiting: When embedding 200 pages for the first time, I hit Google's "Resource Exhausted" errors. I solved this by implementing Exponential Backoff logic—the script now automatically waits and retries if the API gets overwhelmed.

Library Shifts: In 2026, LangChain moved to a modular structure. I adapted by using langchain-classic to keep the robust retrieval chains working while staying compatible with the latest updates.

The Result

What started as a static PDF is now a dynamic SQL expert. I can ask, "How do I create a customer table with specific DB2 constraints?" and within seconds, the bot retrieves the correct syntax from the manual and formats the code for me.

For any software engineer working with heavy documentation, this RAG setup is a game-changer. It moves us from "searching for info" to "acting on info."

Youtube
GitHUb

Building an AI-Powered Expense Tracker with Spring Boot, Spring AI, and Google Gemini

Swapnil Take — Sat, 06 Sep 2025 16:52:42 +0000

Managing personal finances is one of the most common challenges in today’s world. While traditional expense trackers record spending, they don’t provide actionable insights.
That’s where AI-powered applications step in.

In this blog, I’ll walk you through a project where I built an Expense Tracker integrated with Google Gemini AI using Spring Boot and Spring AI.
This application not only tracks expenses but also provides real-time cost-saving suggestions and insights powered by Gemini.

🚀 Project Overview

The AI Expense Tracker is a backend application that:

Records user expenses (category, amount, description, date).

Stores data in a relational database (MySQL).

Provides JWT-secured APIs for expense management.

Integrates with Google Gemini AI using Spring AI.

Generates personalized suggestions to help reduce unnecessary spending.

👉 Imagine logging your food, shopping, and entertainment expenses, and the system automatically tells you:

“Cut down on shopping and try cooking at home more often — you can save ₹3,000 this month.”

That’s the power of combining Spring Boot + AI.

🛠️ Tech Stack

Java 17

Spring Boot 3

Spring Security + JWT (for authentication)

Spring AI (to connect Gemini with Spring Boot)

Google Gemini API (AI model for insights)

Hibernate + JPA (ORM)

MySQL (database)

Postman (API testing)

⚙️ Architecture

Expense Entity

Stores data like amount, category, description, date, and user reference.

Repository Layer

Fetches user expenses from the MySQL database.

Gemini Integration

Expense data is sent to Gemini API.

Gemini analyzes patterns and returns actionable suggestions.

Controller Layer

REST endpoints expose expense tracking and AI analysis features.

🔑 Key Features

✔️ Track Expenses – Add, update, and fetch expenses.
✔️ AI-Powered Suggestions – Get real-time insights on saving money.
✔️ JWT Security – Secure access to APIs.
✔️ Postman Testing – Simple interface for testing endpoints.
✔️ Custom Prompts – Tailor AI responses to be short, simple, and actionable.

🧩 Example Workflow

User adds expenses:

[ { "category": "Food", "amount": 12000, "description": "Restaurant & groceries" }, { "category": "Shopping", "amount": 8000, "description": "Clothes & shoes" }, { "category": "Transport", "amount": 5000, "description": "Cab & fuel" } ]

System prepares AI prompt:

Here are the user's expenses:

Food: 12000
Shopping: 8000
Transport: 5000

Please suggest 3-5 short, simple, actionable tips to save money.

Gemini AI Response:

Cook at home instead of frequent dining out.
Delay non-essential shopping purchases.
Use public transport or carpool to reduce travel costs.
Cancel unused subscriptions.

📊 Why This Project Matters

💡 Traditional expense trackers = record keeping only.
💡 AI Expense Tracker = real-time insights.

By integrating AI, we shift from “What I spent” → “How I can save.”

This project is a great example of practical AI integration into real-world apps using Spring Boot.

🎥 Project Demo

👉 Watch the full demo on YouTube here:
Youtube Video

✅ That’s it! We’ve combined Spring Boot, Spring AI, and Gemini to build something genuinely useful and future-proof.

Setting Up a CI/CD Pipeline with AWS and Git: A Comprehensive Guide

Swapnil Take — Sun, 31 Mar 2024 09:12:08 +0000

In this guide, we'll walk through how to create a simple and efficient way to automatically test and deploy your code using AWS (Amazon Web Services) and Git, without using complicated jargon.

Understanding CI/CD:

What it does: CI (Continuous Integration) helps you automatically test your code whenever you make changes. CD (Continuous Deployment) automatically sends those changes to your website or app.
Why it's useful: It makes sure your code works well and gets updated quickly without causing problems.

Setting Up a Git Repository:

Choose Git: It's a tool that helps you manage your code and keep track of changes.
Create a Repository: Think of it like a folder where you keep all your project's files. You can do this on websites like GitHub.
Decide on a Workflow: This helps you and your team work together smoothly. You might want to use a simple one like "main" for the main code and "feature" for new ideas.

Configuring AWS Services:

AWS CodeCommit: It's like a safe place to store your code online, and only you and your team can access it.
AWS CodeBuild: This helps you test your code automatically to make sure it works as expected.
AWS CodeDeploy: It's like a robot that helps you send your code to your website or app without needing to do it manually.
AWS CodePipeline: It's like a manager that helps all these AWS services work together smoothly.

Building the CI/CD Pipeline:

Make a Plan: Decide what steps your code should go through before it's ready to be shown to the world.
Set Up Triggers: These are like alarms that tell your pipeline to start working whenever you or your team make changes to the code.
Write Instructions: Tell AWS how to test and deploy your code using simple instructions.
Decide Where to Deploy: Choose where you want your code to go, like a website or an app store.

Integrating Testing and Quality Checks:

Test Your Code: Make sure it works correctly by running tests automatically.
Check for Quality: Make sure your code is easy to read and doesn't have mistakes by using special tools that help you check it.

Monitoring and Logging:

Keep an Eye on Things: Make sure everything is running smoothly by checking logs and messages.
Get Notified: Set up messages to tell you if something goes wrong so you can fix it quickly.
Security Best Practices:

Keep Things Safe: Make sure only the right people can access your code and your AWS services.
Protect Your Data: Make sure your information stays private and secure by using encryption.

Saving Excel Data to SQL and NoSQL Databases with Spring Boot

Swapnil Take — Thu, 21 Mar 2024 07:27:17 +0000

In today's tech-driven landscape, efficient data management is paramount. Saving data from Excel files directly into databases is a common requirement for many applications. In this blog post, we'll explore how to achieve this using a Spring Boot project, offering simplicity and robustness in our solution.

Introduction:
Spring Boot provides a powerful framework for building Java applications with ease. Leveraging its capabilities, we'll demonstrate how to parse Excel data and save it into both SQL and NoSQL databases, providing flexibility and scalability for various use cases.

Step 1: Setting Up the Spring Boot Project:
Begin by creating a new Spring Boot project using your favorite IDE or Spring Initializr. Include dependencies for Spring Data JPA and Spring Data MongoDB to facilitate interaction with SQL and NoSQL databases, respectively.

Step 2: Parsing Excel Data:
Utilize libraries like Apache POI or Apache POI OOXML to read and parse Excel files within your Spring Boot application. Extract the data from the Excel sheets and convert it into Java objects or DTOs (Data Transfer Objects) for further processing.

Step 3: Saving to SQL Database:
Define JPA entities corresponding to the data structure in your SQL database. Use Spring Data JPA repositories to handle CRUD (Create, Read, Update, Delete) operations. Iterate through the parsed Excel data and save each record into the SQL database using JPA repository methods.

Step 4: Saving to NoSQL Database:
For NoSQL databases like MongoDB, define MongoDB entities or documents representing the data model. Utilize Spring Data MongoDB repositories to interact with the MongoDB database. Iterate through the parsed Excel data and save each document into the MongoDB collection using MongoDB repository methods.

Step 5: Error Handling and Transaction Management:
Implement error handling mechanisms to handle exceptions gracefully during the data import process. Utilize Spring's transaction management capabilities to ensure data integrity, rolling back transactions in case of failures.

Check Source Code

Conclusion:
By integrating Excel data import functionality into a Spring Boot project, we achieve a robust and efficient solution for saving data into both SQL and NoSQL databases. This approach provides developers with the flexibility to choose the appropriate database technology based on their application requirements.

Stay Connected:
For more tutorials, tips, and insights on Spring Boot development and database management, stay tuned to our blog. Follow us on social media for the latest updates and announcements.

Happy coding with Spring Boot! 🌱

Decoding APIs: From Concept to Implementation: API & REST

Swapnil Take — Thu, 21 Mar 2024 07:07:09 +0000

API, short for Application Programming Interface, acts as a bridge between different software applications. It establishes rules and tools allowing these applications to communicate with each other. In essence, APIs define how software systems can interact without needing to know the internal workings of one another.

Types of APIs

Web APIs (or Web Services): These are accessed over the internet using standard web protocols like HTTP. They facilitate communication between web servers and client applications.
Library APIs: These are sets of functions and procedures that allow developers to create software applications more efficiently by providing pre-written code for common tasks.
OS APIs: Operating System APIs provide functions and procedures for programmers to utilize the capabilities of the underlying operating system.

RESTful APIs and REST Guidelines

REST, or Representational State Transfer, is an architectural style for designing networked applications. RESTful APIs adhere to REST principles, using standard HTTP methods (GET, POST, PUT, DELETE) for communication. They are designed to be stateless, scalable, and easy to understand.

Key Concepts:

Resources: These are entities or concepts that can be identified and manipulated over the web, such as students, employees, or products. Each resource is uniquely identified by a URI.
HTTP Methods: APIs define operations to manipulate resources, including GET (retrieve), POST (create), PUT (update), and DELETE (delete).
JSON: Representing data in JSON format (key-value pairs) is common in RESTful APIs for data exchange.
Stateless: Each client-server request contains all necessary information, and the server does not store client state between requests.

Designing Action-Centric APIs

While traditional REST APIs focus on resources, it's possible to design APIs centered around actions or operations. Here are some tips:

Identify Operations: Clearly define the actions you want to expose through your API.
Use Nouns for Actions: Represent actions with nouns in your URI paths (e.g., /calculations instead of /calculate).
Choose HTTP Methods: Decide on appropriate HTTP methods for your actions, considering POST for most operations.
Document Clearly: Provide comprehensive documentation specifying available actions, parameters, and response formats.
Consider Security: Implement proper authentication and authorization mechanisms for your API, depending on the nature of actions.

Annotations for Working with APIs

@Controller: Marks a class as a controller component in Spring MVC.
@ResponseBody: Indicates that the return value of a method should be serialized directly to the HTTP response body.
@RestController: Combines @Controller and @ResponseBody, simplifying RESTful API development.
@RequestParam: Binds parameters from the request to method parameters in Spring MVC.
@RequestBody: Binds the body of a web request to method parameters in Spring MVC.
@GetMapping, @PostMapping: Maps HTTP GET and POST requests to handler methods.
@RequestMapping: Maps HTTP requests to handler methods, providing more flexibility in URI mapping.
@PathVariable: Extracts values from the URI path in Spring MVC.