Forem: Rohith Davuluri

How I Used AI Agents🤖 to Automate What Used to Take My Team 3 Days

Rohith Davuluri — Sat, 02 May 2026 12:39:12 +0000

Let me be honest with you. Six months ago, our team was spending 3 full days every sprint doing something that felt important but was completely manual — discovering, mapping, and documenting database schemas for compliance reporting.

Today? AI agents do it in under 2 hours. Here’s exactly what changed.

The Problem Nobody Talks About

In banking and enterprise environments, compliance work is brutal. Before every audit cycle, someone on the team had to:

• Manually connect to dozens of databases
• Document every table, column, and relationship
• Map schemas to business logic
• Generate SQL queries for compliance reports
• Write documentation that would be outdated in 2 weeks

This wasn’t glamorous work. It was 3 days of copy-paste, context switching, and human error.

Sound familiar?

The Moment I Decided to Automate It

I remember sitting at my desk at 11 PM finishing a schema mapping document that I knew would need to be redone in 6 weeks. That was the moment I thought — this is exactly what AI agents are built for.

I had been building multi-agent systems at work using Google ADK and Gemini AI. The question wasn’t whether it was possible. It was whether I could make it reliable enough for production in a compliance environment.

Spoiler: I could.

What I Built — The db_discovery Pipeline

I built a 9-agent sequential pipeline where each agent has one job and does it perfectly.

Here’s the architecture:

Parser Agent
↓
Schema Discovery Agent
↓
Data Sampler Agent
↓
Analysis Agent
↓
Graph Builder Agent
↓
Graph Query Agent
↓
Mapper Agent
↓
SQL Generator Agent
↓
Report Generator Agent

Each agent takes input from the previous one, does its specific task, and passes results forward. Clean. Reliable. Auditable.

How Each Agent Works

Agent 1 — Parser

Reads connection configs and validates database credentials. No hardcoded secrets — everything encrypted and stored securely.

from google.adk.agents import Agent

parser_agent = Agent(
name="parser_agent",
model=Gemini(model="gemini-2.0-flash"),
instruction="""
Parse the database configuration provided.
Validate all required fields are present.
Return structured connection parameters.
""",
tools=[validate_connection, decrypt_credentials]
)

Agent 2 — Schema Discovery

Connects to the database and extracts every table, column, data type, and constraint automatically.

schema_agent = Agent(
name="schema_discovery_agent",
model=Gemini(model="gemini-2.0-flash"),
instruction="""
Connect to the database and discover all schemas.
Extract tables, columns, types, and relationships.
Return complete schema inventory.
""",
tools=[connect_database, extract_schema, get_relationships]
)

Agents 3–8

Each handles one specific task — sampling data, analyzing patterns, building knowledge graphs, querying them, mapping to business logic, and generating SQL.

Agent 9 — Report Generator

Takes everything upstream agents produced and generates a complete compliance report. Automatically. In minutes.

The Results

Task	Before	After
Schema discovery	4 hours	8 minutes
Data mapping	6 hours	15 minutes
SQL generation	4 hours	5 minutes
Report writing	10 hours	12 minutes
Total	~3 days	~40 minutes

That’s not an exaggeration. Those are real numbers from our production system.

The Hardest Part Nobody Warned Me About

Building the agents was honestly the easy part. The hard parts were:

LLM Timeouts
When schemas are large, Gemini would timeout mid-pipeline. Fix: pre-filter schemas using TF-IDF before sending to the LLM, so it only processes the most relevant subset.
JSON Sanitization
Agents passing malformed JSON to the next agent would silently break the pipeline. Fix: strict output validation between every agent handoff.
Database Auth in Enterprise
Hardcoded credentials are a compliance nightmare. Fix: encrypted connection strings stored in a secure database, fetched at runtime.

Each of these took me days to figure out. Hopefully this saves you that time.

What This Taught Me About AI Agents

The biggest lesson wasn’t technical. It was this:

AI agents aren’t magic. They’re reliable only when you treat them like production software — with error handling, validation, logging, and testing.

The teams that are winning with AI right now aren’t the ones using the fanciest models. They’re the ones building boring, reliable, well-engineered pipelines around good models.

Could You Build This?

Yes — if you have:

• Python 3.9+
• Google ADK installed
• Access to Gemini API
• A database to connect to

The pattern is simple even if the implementation takes work. Start with 2 agents. Get that working. Add more.

What’s Next For Me

I’m now extending this pipeline to handle multiple database types simultaneously and adding a natural language query interface on top — so non-technical compliance officers can ask questions in plain English and get answers.

The 3-day task is now 40 minutes. The goal is 10.

If you found this useful, follow me — I share what I’m actually building, not just what sounds impressive.

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. 🚀