Upwork-AI-jobs-applier

Extracts job listings from Upwork search results using Playwright-based browser automation that navigates the DOM, handles dynamic content loading, and parses structured job metadata (title, description, budget, client history, skills required). The UpworkJobScraper class in src/scraper.py manages headless browser sessions, implements retry logic for network failures, and extracts job details into structured Pydantic models for downstream processing.

Evaluates scraped job listings against user profile using an LLM-based scoring system that analyzes skills match, budget alignment, client history, and project complexity. The score_jobs_batch node in src/nodes.py orchestrates batch processing through LangChain LLM calls with structured output parsing (Pydantic), filters jobs with scores ≥7/10, and persists qualified jobs to SQLite. Uses multi-provider LLM support (OpenAI, Google, Groq, Anthropic) via a provider factory pattern.

Integrates LangSmith cloud-based monitoring platform to trace AI agent interactions, log LLM calls, and debug workflow failures. Environment configuration (.env.example) includes LANGSMITH_API_KEY and LANGSMITH_PROJECT settings; when enabled, all LLM calls, node executions, and state transitions are logged to LangSmith dashboard for analysis. Enables visualization of workflow DAG execution, token usage tracking, and error diagnosis without code instrumentation.

Generates human-readable markdown files for each processed job containing cover letter, interview preparation guide, and job metadata. The system writes separate markdown files to output directory (configurable path) with structured sections (Job Summary, Cover Letter, Interview Prep, Talking Points), enabling users to review and edit generated content before submission. Files are named by job ID and timestamp for easy organization and version tracking.

Manages user profile data (skills, experience level, hourly rate, portfolio links, certifications) through configuration files or environment variables, enabling the system to match jobs against freelancer qualifications. The user profile is loaded at startup and used throughout the workflow for job scoring, cover letter personalization, and interview preparation. Supports multiple profile formats (JSON, YAML, environment variables) for flexibility.

Generates customized cover letters for qualified jobs using LLM-based text generation that incorporates job description keywords, user skills, relevant experience, and client-specific context. The generate_cover_letter subgraph node in src/nodes.py constructs prompts that reference the job posting, user profile, and previous successful proposals, then uses structured LLM output to produce markdown-formatted cover letters optimized for Upwork's proposal system. Results are persisted to markdown files and database.

Generates interview talking points, potential questions, and discussion strategies for qualified jobs using LLM analysis of job description, client profile, and user expertise. The generate_interview_preparation subgraph node creates markdown documents with anticipated client questions, suggested answers referencing user experience, project discussion points, and rate negotiation strategies. Outputs are stored as markdown files and database records for reference during client calls.

Orchestrates the entire job application pipeline using LangGraph's state machine pattern, where src/graph.py defines a directed acyclic graph (DAG) of processing nodes (scraping, scoring, cover letter generation, interview prep) with explicit state transitions and conditional routing. The UpworkAutomation class manages a TypedDict-based state object (src/state.py) that flows through nodes, persisting intermediate results and enabling resumable execution. Supports parallel batch processing and integrates LangSmith for observability.

Maintains a SQLite database (src/database.py) that stores processed jobs, application history, and generated content to prevent reprocessing and enable historical analysis. The check_jobs_against_db node queries the database before scoring to identify previously seen jobs, stores qualified jobs with metadata (score, timestamp, cover letter, interview prep), and supports queries for analytics (jobs applied, success rate, average score). Database schema includes job_listings, applications, and metadata tables with indexed lookups.

Provides a provider factory pattern (src/utils.py) that abstracts LLM interactions across OpenAI, Google Generative AI, Groq, and Anthropic, allowing runtime provider selection via environment variables without code changes. Each provider is wrapped in a consistent interface that handles API authentication, request formatting, structured output parsing (via Pydantic), and error handling. Supports provider-specific features (e.g., Groq's fast inference, Anthropic's extended context) while maintaining API compatibility.

Processes multiple jobs in parallel batches using LangGraph's batch execution capabilities while respecting API rate limits through configurable delays and batch sizes. The score_jobs_batch node groups jobs into batches, submits them to the LLM in parallel (up to N concurrent requests), and implements exponential backoff for rate limit errors. Batch size and concurrency are configurable via environment variables to balance speed vs. API quota consumption.

Enforces type safety and consistent data structures across the workflow using Pydantic models (v2.9.2) for job objects, user profiles, scores, and generated content. LLM responses are parsed into Pydantic models with validation, ensuring required fields are present and types are correct. If parsing fails, the system retries with a corrected prompt or falls back to manual review. Models are defined in src/models.py and used throughout the pipeline for type hints and runtime validation.

Packages the entire automation system as a Docker container (Dockerfile, .dockerignore) with environment-based configuration via .env file, enabling deployment to cloud platforms (AWS, GCP, Azure) or local Docker environments without code changes. Container includes all dependencies (Python, Playwright, LangChain, LangGraph), exposes configuration via environment variables, and supports volume mounts for database persistence and output files. Deployment documentation covers Docker setup, environment variable configuration, and cloud deployment patterns.