DEV Community: Rohith Davuluri

TF-IDF + LLM Reranking: How I Improved Vector Search Accuracy from 60% to 86%

Rohith Davuluri — Sat, 25 Apr 2026 07:24:22 +0000

TF-IDF + LLM Reranking: How I Improved Vector Search Accuracy from 60% to 86%
Vector search is powerful — but it’s not perfect. When I was building a database discovery pipeline at work, our initial semantic search was only matching the right schemas about 60% of the time. That wasn’t good enough for production. Here’s exactly how I fixed it using a hybrid TF-IDF and LLM reranking approach.
The Problem
Our pipeline needed to match user queries to the correct database schemas from a large pool of candidates. Pure vector search (embeddings + cosine similarity) was fast but kept returning semantically similar but contextually wrong results.
For example, searching for “customer account balance” would return results about “user wallet transactions” — close, but not what we needed in a strict banking compliance context.
The Solution: Hybrid Retrieval + LLM Reranking
Instead of relying on one method, I combined three layers:
1. TF-IDF for keyword precision
2. Vector embeddings for semantic similarity
3. LLM reranking for contextual judgment
Step 1 — TF-IDF First Pass
TF-IDF is great at catching exact keyword matches that embeddings sometimes miss:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

def tfidf_retrieve(query: str, corpus: list, top_k: int = 20) -> list:
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(corpus)
query_vec = vectorizer.transform([query])
scores = cosine_similarity(query_vec, tfidf_matrix).flatten()
top_indices = np.argsort(scores)[::-1][:top_k]
return [(corpus[i], scores[i]) for i in top_indices]

This gives us a broad candidate set of top 20 results.
Step 2 — Vector Embedding Re-Filter
Next we re-score those 20 candidates using semantic embeddings:

from sentence_transformers import SentenceTransformer
import numpy as np

model = SentenceTransformer("all-MiniLM-L6-v2")

def embedding_rerank(query: str, candidates: list, top_k: int = 5) -> list:
query_embedding = model.encode(query)
scored = []
for text, _ in candidates:
emb = model.encode(text)
score = np.dot(query_embedding, emb)
scored.append((text, score))
scored.sort(key=lambda x: x[1], reverse=True)
return scored[:top_k]

Now we’re down to top 5 highly relevant candidates.
Step 3 — LLM Reranking
This is where the magic happens. We ask Gemini to pick the best match:

import google.generativeai as genai

def llm_rerank(query: str, candidates: list) -> str:
candidate_text = "\n".join(
[f"{i+1}. {c[0]}" for i, c in enumerate(candidates)]
)
prompt = f"""
Query: {query}

Candidates:
{candidate_text}

Which candidate best matches the query in a banking compliance context?
Return only the number of the best match.
"""
model = genai.GenerativeModel("gemini-2.0-flash")
response = model.generate_content(prompt)
return candidates[int(response.text.strip()) - 1][0]

The LLM understands context, domain specifics, and nuance that pure math simply can’t capture.
The Results

Method	Accuracy
Vector search only	~60%
TF-IDF only	~65%
TF-IDF + Embeddings	~75%
Full hybrid + LLM rerank	86%

Each layer added meaningful improvement. The LLM reranking alone jumped accuracy by 11 points.
Why This Works
• TF-IDF catches exact terminology matches
• Embeddings capture semantic meaning
• LLM applies domain reasoning and context
No single method is perfect. Combined, they cover each other’s weaknesses.
When Should You Use This?
Use this approach when:
• Your search corpus is domain-specific (legal, medical, banking)
• Exact keyword matches matter alongside semantic meaning
• You can afford a small LLM call per query
• Accuracy matters more than raw speed
Key Takeaway
Don’t default to pure vector search just because it’s trendy. A hybrid approach with LLM reranking is more accurate for specialized domains — and the implementation is simpler than you’d think.
Follow me for more practical AI engineering content. 🚀

Why I Use Playwright for AI Agent Automation (And You Should Too)

Rohith Davuluri — Sat, 25 Apr 2026 07:21:34 +0000

Why I Use Playwright for AI Agent Automation (And You Should Too)
When I first started building AI agents that needed to interact with web-based banking systems, I tried everything — Selenium, requests, BeautifulSoup. Nothing came close to what Playwright offers. Here’s why I switched and never looked back.
What is Playwright?
Playwright is a modern browser automation library developed by Microsoft. It supports Chromium, Firefox, and WebKit, and works seamlessly with Python, JavaScript, and TypeScript.
But what makes it special for AI agent workflows isn’t just speed — it’s reliability.
The Problem With Other Tools
Traditional automation tools struggle with:
• Dynamic JavaScript-rendered content
• Complex login flows and session management
• Multi-step form interactions
• Real-time page state changes
AI agents need to navigate these challenges autonomously. One failed selector and the entire workflow breaks.
Why Playwright Wins for AI Agents

Auto-Waiting Playwright automatically waits for elements to be ready before interacting. No more:

time.sleep(3) # the old way

Instead:

await page.click("#submit-button") # waits automatically

This alone eliminates 80% of flaky automation failures.

Powerful Selectors Playwright supports multiple selector strategies:

By text

await page.get_by_text("Login").click()

By role

await page.get_by_role("button", name="Submit").click()

By placeholder

await page.get_by_placeholder("Enter username").fill("rohith")

These make your agents resilient to minor UI changes.

Screenshot and State Capture AI agents often need to verify what they’re seeing:

await page.screenshot(path="current_state.png")
content = await page.content()

This is incredibly useful for debugging agent behavior and feeding visual context back to your LLM.

Headless and Headed Modes Run silently in production:

browser = await playwright.chromium.launch(headless=True)

Or visually during development:

browser = await playwright.chromium.launch(headless=False)

Real-World Example
Here’s a simplified version of how I use Playwright inside an AI agent for web navigation:

from playwright.async_api import async_playwright

async def extract_account_data(url: str, credentials: dict) -> str:
async with async_playwright() as p:
browser = await p.chromium.launch(headless=True)
page = await browser.new_page()

    await page.goto(url)
    await page.get_by_placeholder("Username").fill(credentials["username"])
    await page.get_by_placeholder("Password").fill(credentials["password"])
    await page.get_by_role("button", name="Login").click()
    await page.wait_for_load_state("networkidle")

    data = await page.inner_text(".account-summary")
    await browser.close()
    return data

The agent calls this function as a tool, processes the returned data with an LLM, and takes the next action. Clean, reliable, production-ready.
When Should You Use Playwright?
Use Playwright when your AI agent needs to:
• Log into web applications
• Extract data from dynamic dashboards
• Fill and submit multi-step forms
• Navigate complex enterprise portals
• Take screenshots for visual verification
Getting Started

pip install playwright
playwright install chromium

That’s it. You’re ready to build agents that can actually interact with the web like a human.
Final Thoughts
Playwright isn’t just a testing tool — it’s a powerful engine for AI agent automation. If you’re building agents that need to interact with the real web, stop fighting with unreliable tools and give Playwright a try.
Follow me for more practical AI engineering content. 🚀

Getting Started with Google ADK: Build Your First AI Agent in Python

Rohith Davuluri — Sat, 25 Apr 2026 07:14:54 +0000

AI agents are no longer just research concepts — they’re being deployed in production systems across industries. Google’s Agent Development Kit (ADK) makes it easier than ever to build, orchestrate, and deploy intelligent agents using Python. In this guide, I’ll walk you through building your first AI agent from scratch using Google ADK.
What is Google ADK?
Google ADK (Agent Development Kit) is an open-source framework designed to help developers build multi-agent AI systems. It provides:
• A structured way to define agents and their tools
• Built-in orchestration for sequential and parallel workflows
• Native integration with Gemini AI models
• YAML-based configuration for agent behavior
Think of it as the backbone that connects your AI model to real-world actions.
Prerequisites
Before we start, make sure you have:
• Python 3.9+
• A Google Cloud account
• Gemini API access
• Basic Python knowledge
Installation

pip install google-adk
pip install google-generativeai

Building Your First Agent
Let’s build a simple research agent that can answer questions using tools.
Step 1 — Define Your Tool
Tools are functions your agent can call to interact with the world.

def search_knowledge_base(query: str) -> str:
"""Search internal knowledge base for information."""
# Your logic here
return f"Results for: {query}"

Step 2 — Create the Agent

from google.adk.agents import Agent
from google.adk.models import Gemini

agent = Agent(
name="research_agent",
model=Gemini(model="gemini-2.0-flash"),
description="An agent that answers questions",
instruction="You are a helpful research assistant. Use your tools to find accurate information.",
tools=[search_knowledge_base]
)

Step 3 — Run the Agent

from google.adk.runners import Runner

runner = Runner(agent=agent)
response = runner.run("What is machine learning?")
print(response)

How It Works
When you send a query to the agent:
1. Gemini receives your input
2. Decides whether to use a tool or respond directly
3. Calls the tool if needed and gets results
4. Formulates a final response
This loop is what makes agents powerful — they can reason, act, and respond dynamically.
Real-World Use Case
At my day job, I use Google ADK to build multi-agent pipelines for banking compliance automation. One pipeline I built has 9 sequential agents — each handling a specific task like schema discovery, data sampling, and SQL generation. ADK made orchestrating all of them clean and maintainable.
What’s Next?
Once you’re comfortable with a single agent, you can:
• Chain multiple agents sequentially
• Run agents in parallel for faster pipelines
• Add memory and context persistence
• Integrate with databases and external APIs
Conclusion
Google ADK is one of the most practical frameworks for building production-grade AI agents today. With just a few lines of Python, you can have an intelligent agent running and ready to extend.
If you found this helpful, follow me for more content on AI agents, automation, and GenAI engineering. 🚀