Two AI agents work together to research a company, analyze your resume, generate 50 tailored interview questions, and build a complete interview preparation kit — all in under 5 minutes.
Features · Architecture · Quick Start · API Keys · Usage · Tech Stack · Project Structure · Troubleshooting
| Feature | Description |
|---|---|
| Company Research | Automated web research using Tavily AI — company overview, key facts, culture signals, Glassdoor/AmbitionBox reviews |
| Interview Process | Discovers interview rounds, format, difficulty level, and preparation tips |
| Deep Resume Review | Compares your resume against the JD, identifies matching and missing keywords, provides before/after bullet rewrites |
| 50 Tailored Questions | Generates 25 technical + 25 behavioral questions specific to the role and your experience level |
| Preparation Guide | Topic-wise study plan with priority levels, time estimates, resources, and practice methods |
| Salary Intelligence | Extracts real salary data from AmbitionBox/Glassdoor using regex parsing — not LLM guesses |
| Negotiation Scripts | Word-for-word scripts for salary discussions and counter-offers |
| Confidence Assessment | Detailed readiness score (1-10) with specific strengths, gaps, and actionable recommendations |
| Downloadable Report | Full prep kit exportable as a .txt file |
┌─────────────────────────────────────────────────────────┐
│ SHARED STATE │
│ (Python TypedDict dictionary) │
│ Carries all data between agents — inputs, research, │
│ coaching outputs, errors, and control signals │
└─────────────────────────────────────────────────────────┘
│ │ │ │
┌────▼────┐ ┌─────▼─────┐ ┌────▼─────┐ ┌────▼────┐
│ collect │ │ agent1 │ │ agent2 │ │generate │
│ input │──▶│ research │─▶│ coach │─▶│ report │
│ │ │ │ │ │ │ │
│ Validate │ │ NVIDIA NIM│ │ Groq │ │ Format │
│ & clean │ │ + Tavily │ │ 6 calls │ │ output │
└─────────┘ └───────────┘ └──────────┘ └─────────┘
│ │
┌────┴────┐ ┌────┴────┐
│ Tavily │ │ Groq │
│ Search │ │ LLM API │
│ (10x) │ │(6 calls)│
└─────────┘ └─────────┘
-
collect_input — Validates and sanitizes all user inputs (company, role, experience, resume, JD)
-
agent1_research (NVIDIA NIM + Tavily) — Runs 10 targeted web searches, extracts real salary data via regex from AmbitionBox/Glassdoor pages, and sends all raw results to NVIDIA NIM for structured synthesis into company info, culture signals, interview process, and JD keywords
-
agent2_coach (Groq) — Makes 6 sequential LLM calls with 15-second rate-limit delays between each:
- Company brief + confidence assessment
- Deep resume review with rewrite suggestions
- Complete preparation guide with prioritized topics
- Salary negotiation strategy and scripts
- 25 technical interview questions
- 25 behavioral interview questions
-
generate_report — Assembles all outputs into a downloadable plain-text report
- Python 3.11 (recommended — tested and verified)
- Internet connection
- 3 free API keys (see API Keys section below)
# Clone or unzip the project
cd agentic-interview-coach
# Create virtual environment (choose one)
# Option A: venv
python -m venv venv
# Windows:
venv\Scripts\activate
# Mac/Linux:
source venv/bin/activate
# Option B: conda
conda create -n interview-coach python=3.11 -y
conda activate interview-coach
# Option C: uv (fastest)
pip install uv
uv venv --python 3.11
# Windows: .venv\Scripts\activate
# Mac/Linux: source .venv/bin/activate
# Install dependencies
pip install -r requirements.txt# Copy the environment template
cp .env.example .env
# Open .env and paste your 3 API keys (see next section)streamlit run app.pyThe app opens at http://localhost:8501
This project uses 3 free APIs. No credit card required for any of them.
Groq provides ultra-fast inference for the coaching agent (Llama 3.3 70B).
| Free Tier | 14,400 requests/day · 100,000 tokens/day |
| Sign Up | console.groq.com |
| Key Prefix | gsk_ |
Steps:
- Go to console.groq.com and sign up with Google or GitHub
- Click API Keys in the left sidebar
- Click Create API Key, give it any name
- Copy the key — it starts with
gsk_
NVIDIA NIM hosts the research synthesis model (Llama 3.1 70B).
| Free Tier | 1,000 credits on signup |
| Sign Up | build.nvidia.com |
| Key Prefix | nvapi- |
Steps:
- Go to build.nvidia.com and create an account
- Search for any model (e.g., "Llama 3.1 70B Instruct")
- Click Get API Key
- Copy the key — it starts with
nvapi-
Tavily replaces traditional web scraping with AI-optimized search results.
| Free Tier | 1,000 searches/month |
| Sign Up | app.tavily.com |
| Key Prefix | tvly- |
Steps:
- Go to app.tavily.com and sign up
- Your API key is shown on the dashboard
- Copy the key — it starts with
tvly-
After obtaining all 3 keys, your .env file should look like:
GROQ_API_KEY=gsk_xxxxxxxxxxxxxxxxxxxxxxxx
NVIDIA_API_KEY=nvapi-xxxxxxxxxxxxxxxxxxxxxxxx
TAVILY_API_KEY=tvly-xxxxxxxxxxxxxxxxxxxxxxxx- Enter Company Name — e.g., "Google", "Infosys", "Razorpay"
- Enter Role — e.g., "Senior Data Scientist", "ML Engineer"
- Enter Experience — free text, e.g., "Fresher", "2 years 6 months", "5 years"
- Paste Job Description — copy the full JD from the job posting
- Upload Resume — PDF format
- Click "Prepare Me for the Interview" — wait 3-5 minutes for the agents to complete
| Section | What You Get |
|---|---|
| 🟢 Readiness Score | 1-10 rating with detailed assessment of strengths and gaps |
| 🏢 Company Brief | 2-paragraph summary + smart question to ask the interviewer |
| 💡 Key Facts | Funding, partnerships, tech stack, awards — things worth knowing |
| 🔄 Interview Process | Round-by-round breakdown with format, duration, and tips |
| 🏛️ Culture & Reviews | Glassdoor/AmbitionBox positives, negatives, and scores |
| 📝 Resume Review | Keyword analysis, before/after bullet rewrites, new bullets to add |
| 📚 How to Prepare | Prioritized topic list with time estimates and resources |
| 🎤 50 Questions | 25 technical + 25 behavioral, tailored to the JD |
| 💰 Salary Strategy | Real salary range + word-for-word negotiation scripts |
| 🚩 Red Flags | Evidence-based concerns (or "no red flags found") |
| Component | Technology | Role |
|---|---|---|
| Agent Orchestration | LangGraph | Defines the multi-agent workflow as a graph of nodes and edges |
| Researcher LLM | NVIDIA NIM — Llama 3.1 70B | Synthesizes web research into structured JSON |
| Coach LLM | Groq — Llama 3.3 70B | Generates coaching content, questions, and analysis |
| Web Search | Tavily | AI-optimized search + page extraction (replaces scraping) |
| PDF Parsing | PyMuPDF | Extracts text from resume PDFs |
| UI Framework | Streamlit | Interactive web application |
| Config | python-dotenv | Loads API keys from .env file |
agentic-interview-coach/
│
├── app.py # Streamlit UI — input form, progress tracking, output rendering
├── graph.py # LangGraph state definition (TypedDict) + graph assembly
│
├── nodes/
│ ├── collect_input.py # Node 1 — input validation and sanitization
│ ├── agent1_research.py # Node 2 — Tavily search + NVIDIA NIM synthesis + salary extraction
│ ├── agent2_coach.py # Node 3 — Groq coaching (6 calls with rate-limit delays)
│ └── generate_report.py # Node 4 — plain-text report assembly
│
├── tools/
│ ├── search_tool.py # Tavily search + extract wrapper functions
│ └── scraper_tool.py # URL extraction via Tavily (replaces BeautifulSoup)
│
├── utils/
│ └── resume_parser.py # PyMuPDF PDF text extraction
│
├── requirements.txt # Python dependencies
├── .env.example # API key template
└── README.md # This file
| Decision | Reasoning |
|---|---|
Sequential node calls in app.py instead of graph.invoke() |
Streamlit needs control of the main thread to show live progress updates. graph.invoke() blocks the UI. Nodes are called directly with st.write passed as a progress callback. |
| 6 separate Groq calls instead of 1 large call | Focused prompts produce better results. If one call fails, others still succeed. Avoids token limit issues. |
| 15-second delays between Groq calls | Groq free tier has a 12,000 tokens/minute limit. Without delays, consecutive calls get 429 rate-limited. |
| Regex salary extraction instead of trusting LLM | LLMs hallucinate salary numbers. The system extracts actual ₹ amounts from AmbitionBox/Glassdoor pages using regex, then overrides the LLM's estimates with real data. |
json.loads(strict=False) |
LLMs often include newline characters inside JSON string values. Python's strict mode rejects these as "invalid control characters". strict=False handles this gracefully. |
| Tavily instead of DuckDuckGo | DuckDuckGo's LangChain wrapper has known hanging issues and returns thin snippets. Tavily returns structured, content-rich results with no timeouts. |
| Problem | Cause | Solution |
|---|---|---|
| Groq 429 rate limit | Per-minute (12K tokens) or daily (100K tokens) limit hit | Wait 60 seconds for per-minute reset. For daily limit, wait 24 hours or use a new Groq account. |
| NVIDIA 504 timeout | Prompt too large or server overloaded | Try again — NVIDIA NIM occasionally has high latency on free tier. |
| Empty sections in output | A Groq or NVIDIA call returned empty/failed | Check terminal logs — every API call is logged with timestamps, response sizes, and error details. |
| "Assessment unavailable" | JSON parse failure on Groq response | Fixed in current version with strict=False. If it persists, check terminal for JSON parse FAILED errors. |
| Salary shows "UNVERIFIED" | Real salary numbers couldn't be extracted from web pages | The system tried regex extraction from AmbitionBox/Glassdoor. If pages didn't contain explicit ₹ amounts, it falls back to LLM estimates marked as unverified. |
Missing tavily-python |
Package not installed | pip install tavily-python |
Missing fitz / pymupdf |
PDF parser not installed | pip install pymupdf (the import name is fitz) |
| venv not activating (Windows) | PowerShell execution policy | Run: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned |
| Python version issues | Running on 3.12+ or 3.9 | Use Python 3.11 specifically |
| Duplicate log lines | Logger initialized twice | Cosmetic only — doesn't affect functionality |
Every API call is logged to the terminal with full details:
[AGENT1] INFO: Search 3/10: Glassdoor reviews # What's being searched
[AGENT1] DEBUG: Search 3 result length: 1832 chars # How much data came back
[AGENT1] INFO: NVIDIA NIM response received: 3116 chars # LLM response size
[AGENT2] INFO: Groq 'resume review' response: 2863 chars
[AGENT2] INFO: JSON parsed OK. Keys: [...] # Parse success
[AGENT2] ERROR: JSON parse FAILED: Invalid control... # Parse failure with details
If any section shows empty or default values, the terminal logs will tell you exactly which call failed and why.
| Phase | Duration | What Happens |
|---|---|---|
| Tavily searches (10x) | ~12 seconds | 10 parallel-safe searches, ~1.2s each |
| NVIDIA NIM synthesis | 2-3 minutes | Single large LLM call to synthesize all research |
| Groq coaching (6 calls) | ~2 minutes | 6 calls × (2-3s response + 15s delay) |
| Total | 3-5 minutes | End-to-end from click to complete output |
MIT License — see LICENSE for details.
Built with LangGraph · NVIDIA NIM · Groq · Tavily · Streamlit
All free-tier APIs. No GPU required. Runs on any laptop.