Skip to content

About

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.

Resources

Stars

3 stars

Watchers

0 watching

Forks

Latest commit

 

History

1 Commit

Folders and files

Repository files navigation

🎯 Agentic Interview Coach

AI-Powered Interview Preparation using Multi-Agent Systems

Python LangGraph Streamlit License

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


✨ Features

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

🏗 Architecture

┌─────────────────────────────────────────────────────────┐
│                    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)│
                  └─────────┘   └─────────┘

How It Works

  1. collect_input — Validates and sanitizes all user inputs (company, role, experience, resume, JD)

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

  3. 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
  4. generate_report — Assembles all outputs into a downloadable plain-text report


🚀 Quick Start

Prerequisites

  • Python 3.11 (recommended — tested and verified)
  • Internet connection
  • 3 free API keys (see API Keys section below)

Installation

# 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

Configuration

# Copy the environment template
cp .env.example .env

# Open .env and paste your 3 API keys (see next section)

Run

streamlit run app.py

The app opens at http://localhost:8501


🔑 API Keys

This project uses 3 free APIs. No credit card required for any of them.

1. Groq — Coach Agent LLM

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:

  1. Go to console.groq.com and sign up with Google or GitHub
  2. Click API Keys in the left sidebar
  3. Click Create API Key, give it any name
  4. Copy the key — it starts with gsk_

2. NVIDIA NIM — Researcher Agent LLM

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:

  1. Go to build.nvidia.com and create an account
  2. Search for any model (e.g., "Llama 3.1 70B Instruct")
  3. Click Get API Key
  4. Copy the key — it starts with nvapi-

3. Tavily — AI Web Search

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:

  1. Go to app.tavily.com and sign up
  2. Your API key is shown on the dashboard
  3. Copy the key — it starts with tvly-

Your .env File

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

💡 Usage

  1. Enter Company Name — e.g., "Google", "Infosys", "Razorpay"
  2. Enter Role — e.g., "Senior Data Scientist", "ML Engineer"
  3. Enter Experience — free text, e.g., "Fresher", "2 years 6 months", "5 years"
  4. Paste Job Description — copy the full JD from the job posting
  5. Upload Resume — PDF format
  6. Click "Prepare Me for the Interview" — wait 3-5 minutes for the agents to complete

Output Sections

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")

🛠 Tech Stack

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

📁 Project Structure

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

Key Design Decisions

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.

❗ Troubleshooting

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

Reading Terminal Logs

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.


⚡ Performance

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

📜 License

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.

About

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.

Resources

Stars

3 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages