Merged conflict resolved

.gitignore

@@ -46,6 +46,7 @@ requirements.txt
 docker-compose.override.example.yml
 DOCKERFILE_EXPLANATION.md
 DEPLOYMENT_GUIDE.md
+<<<<<<< HEAD
 ./src/job_writing_agent/logs/*.log
 
 # Binary files (PDFs, images, etc.)
@@ -56,4 +57,6 @@ DEPLOYMENT_GUIDE.md
 *.gif
 *.zip
 *.tar
-*.gz
+*.gz
+=======
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,303 @@
+# Deployment Guide for Job Application Agent
+
+## Option 1: LangGraph Cloud (Easiest & Recommended)
+
+### Prerequisites
+- LangGraph CLI installed (`langgraph-cli` in requirements.txt)
+- `langgraph.json` already configured ✅
+
+### Steps
+
+1. **Install LangGraph CLI** (if not already):
+```powershell
+pip install langgraph-cli
+```
+
+2. **Login to LangGraph Cloud**:
+```powershell
+langgraph login
+```
+
+3. **Deploy your agent**:
+```powershell
+langgraph deploy
+```
+
+4. **Get your API endpoint** - LangGraph Cloud provides a REST API automatically
+
+### Cost
+- **Free tier**: Limited requests/month
+- **Paid**: Pay-per-use pricing
+
+### Pros
+- ✅ Zero infrastructure management
+- ✅ Built-in state persistence
+- ✅ Automatic API generation
+- ✅ LangSmith integration
+- ✅ Perfect for LangGraph apps
+
+### Cons
+- ⚠️ Vendor lock-in
+- ⚠️ Limited customization
+
+---
+
+## Option 2: Railway.app (Simple & Cheap)
+
+### Steps
+
+1. **Create a FastAPI wrapper** (create `api.py`):
+```python
+from fastapi import FastAPI, File, UploadFile
+from job_writing_agent.workflow import JobWorkflow
+import tempfile
+import os
+
+app = FastAPI()
+
+@app.post("/generate")
+async def generate_application(
+    resume: UploadFile = File(...),
+    job_description: str,
+    content_type: str = "cover_letter"
+):
+    # Save resume temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+        tmp.write(await resume.read())
+        resume_path = tmp.name
+    
+    try:
+        workflow = JobWorkflow(
+            resume=resume_path,
+            job_description_source=job_description,
+            content=content_type
+        )
+        result = await workflow.run()
+        return {"result": result}
+    finally:
+        os.unlink(resume_path)
+```
+
+2. **Create `Procfile`**:
+```
+web: uvicorn api:app --host 0.0.0.0 --port $PORT
+```
+
+3. **Deploy to Railway**:
+   - Sign up at [railway.app](https://railway.app)
+   - Connect GitHub repo
+   - Railway auto-detects Python and runs `Procfile`
+
+### Cost
+- **Free tier**: $5 credit/month
+- **Hobby**: $5/month for 512MB RAM
+- **Pro**: $20/month for 2GB RAM
+
+### Pros
+- ✅ Very simple deployment
+- ✅ Auto-scaling
+- ✅ Free tier available
+- ✅ Automatic HTTPS
+
+### Cons
+- ⚠️ Need to add FastAPI wrapper
+- ⚠️ State management needs Redis/Postgres
+
+---
+
+## Option 3: Render.com (Similar to Railway)
+
+### Steps
+
+1. **Create `render.yaml`**:
+```yaml
+services:
+  - type: web
+    name: job-writer-api
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn api:app --host 0.0.0.0 --port $PORT
+    envVars:
+      - key: OPENROUTER_API_KEY
+        sync: false
+      - key: TAVILY_API_KEY
+        sync: false
+```
+
+2. **Deploy**:
+   - Connect GitHub repo to Render
+   - Render auto-detects `render.yaml`
+
+### Cost
+- **Free tier**: 750 hours/month (sleeps after 15min inactivity)
+- **Starter**: $7/month (always on)
+
+### Pros
+- ✅ Free tier for testing
+- ✅ Simple YAML config
+- ✅ Auto-deploy from Git
+
+### Cons
+- ⚠️ Free tier sleeps (cold starts)
+- ⚠️ Need FastAPI wrapper
+
+---
+
+## Option 4: Fly.io (Good Free Tier)
+
+### Steps
+
+1. **Install Fly CLI**:
+```powershell
+iwr https://fly.io/install.ps1 -useb | iex
+```
+
+2. **Create `Dockerfile`**:
+```dockerfile
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "8080"]
+```
+
+3. **Deploy**:
+```powershell
+fly launch
+fly deploy
+```
+
+### Cost
+- **Free tier**: 3 shared-cpu VMs, 3GB storage
+- **Paid**: $1.94/month per VM
+
+### Pros
+- ✅ Generous free tier
+- ✅ Global edge deployment
+- ✅ Docker-based (flexible)
+
+### Cons
+- ⚠️ Need Docker knowledge
+- ⚠️ Need FastAPI wrapper
+
+---
+
+## Option 5: AWS Lambda (Serverless - Pay Per Use)
+
+### Steps
+
+1. **Create Lambda handler** (`lambda_handler.py`):
+```python
+import json
+from job_writing_agent.workflow import JobWorkflow
+
+def lambda_handler(event, context):
+    # Parse event
+    body = json.loads(event['body'])
+    
+    workflow = JobWorkflow(
+        resume=body['resume_path'],
+        job_description_source=body['job_description'],
+        content=body.get('content_type', 'cover_letter')
+    )
+    
+    result = workflow.run()
+    
+    return {
+        'statusCode': 200,
+        'body': json.dumps({'result': result})
+    }
+```
+
+2. **Package and deploy** using AWS SAM or Serverless Framework
+
+### Cost
+- **Free tier**: 1M requests/month
+- **Paid**: $0.20 per 1M requests + compute time
+
+### Pros
+- ✅ Pay only for usage
+- ✅ Auto-scaling
+- ✅ Very cheap for low traffic
+
+### Cons
+- ⚠️ 15min timeout limit
+- ⚠️ Cold starts
+- ⚠️ Complex setup
+- ⚠️ Need to handle state externally
+
+---
+
+## Recommendation
+
+**For your use case, I recommend:**
+
+1. **Start with LangGraph Cloud** - Easiest, built for your stack
+2. **If you need more control → Railway** - Simple, good free tier
+3. **If you need serverless → AWS Lambda** - Cheapest for low traffic
+
+---
+
+## Quick Start: FastAPI Wrapper (for Railway/Render/Fly.io)
+
+Create `api.py` in your project root:
+
+```python
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from job_writing_agent.workflow import JobWorkflow
+import tempfile
+import os
+import asyncio
+
+app = FastAPI(title="Job Application Writer API")
+
+@app.get("/")
+def health():
+    return {"status": "ok"}
+
+@app.post("/generate")
+async def generate_application(
+    resume: UploadFile = File(...),
+    job_description: str,
+    content_type: str = "cover_letter"
+):
+    """Generate job application material."""
+    # Save resume temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+        content = await resume.read()
+        tmp.write(content)
+        resume_path = tmp.name
+    
+    try:
+        workflow = JobWorkflow(
+            resume=resume_path,
+            job_description_source=job_description,
+            content=content_type
+        )
+        
+        # Run workflow (assuming it's async or can be wrapped)
+        result = await asyncio.to_thread(workflow.run)
+        
+        return JSONResponse({
+            "status": "success",
+            "result": result
+        })
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        # Cleanup
+        if os.path.exists(resume_path):
+            os.unlink(resume_path)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+Then update `requirements.txt` to ensure FastAPI and uvicorn are included (they already are ✅).
+

DOCKERFILE_EXPLANATION.md

@@ -0,0 +1,147 @@
+# Dockerfile Explanation
+
+This Dockerfile is specifically designed for **LangGraph Cloud/LangServe deployment**. It uses the official LangGraph API base image and configures your agent graphs to be served as REST APIs.
+
+## Line-by-Line Breakdown
+
+### 1. Base Image (Line 1)
+```dockerfile
+FROM langchain/langgraph-api:3.12
+```
+- **Purpose**: Uses the official LangGraph API base image with Python 3.12
+- **What it includes**: Pre-configured LangGraph runtime, LangServe server, and all LangGraph dependencies
+- **Why**: This image already has everything needed to serve LangGraph workflows as REST APIs
+
+---
+
+### 2. Install Node Dependencies (Line 9)
+```dockerfile
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt nodes
+```
+- **Purpose**: Installs the `nodes` package (likely a dependency from your `langgraph.json`)
+- **`PYTHONDONTWRITEBYTECODE=1`**: Prevents creating `.pyc` files (smaller image)
+- **`uv pip`**: Uses `uv` (fast Python package installer) instead of regular `pip`
+- **`--system`**: Installs to system Python (not virtual env)
+- **`--no-cache-dir`**: Doesn't cache pip downloads (smaller image)
+- **`-c /api/constraints.txt`**: Uses constraint file from base image (ensures compatible versions)
+
+---
+
+### 3. Copy Your Code (Line 14)
+```dockerfile
+ADD . /deps/job_writer
+```
+- **Purpose**: Copies your entire project into `/deps/job_writer` in the container
+- **Why `/deps/`**: LangGraph API expects dependencies in this directory
+- **What gets copied**: All your source code, `pyproject.toml`, `requirements.txt`, etc.
+
+---
+
+### 4. Install Your Package (Lines 19-21)
+```dockerfile
+RUN for dep in /deps/*; do
+    echo "Installing $dep";
+    if [ -d "$dep" ]; then
+        echo "Installing $dep";
+        (cd "$dep" && PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e .);
+    fi;
+done
+```
+- **Purpose**: Installs your `job_writer` package in editable mode (`-e`)
+- **How it works**: 
+  - Loops through all directories in `/deps/`
+  - For each directory, changes into it and runs `pip install -e .`
+  - The `-e` flag installs in "editable" mode (changes to code are reflected)
+- **Why**: Makes your package importable as `job_writing_agent` inside the container
+
+---
+
+### 5. Register Your Graphs (Line 25)
+```dockerfile
+ENV LANGSERVE_GRAPHS='{"job_app_graph": "/deps/job_writer/src/job_writing_agent/workflow.py:job_app_graph", ...}'
+```
+- **Purpose**: Tells LangServe which graphs to expose as REST APIs
+- **Format**: JSON mapping of `graph_name` → `module_path:attribute_name`
+- **What it does**:
+  - `job_app_graph` → Exposes `JobWorkflow.job_app_graph` property as an API endpoint
+  - `research_workflow` → Exposes the research subgraph
+  - `data_loading_workflow` → Exposes the data loading subgraph
+- **Result**: Each graph becomes a REST API endpoint like `/invoke/job_app_graph`
+
+---
+
+### 6. Protect LangGraph API (Lines 33-35)
+```dockerfile
+RUN mkdir -p /api/langgraph_api /api/langgraph_runtime /api/langgraph_license && \
+    touch /api/langgraph_api/__init__.py /api/langgraph_runtime/__init__.py /api/langgraph_license/__init__.py
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir --no-deps -e /api
+```
+- **Purpose**: Prevents your dependencies from accidentally overwriting LangGraph API packages
+- **How**:
+  1. Creates placeholder `__init__.py` files for LangGraph packages
+  2. Reinstalls LangGraph API (without dependencies) to ensure it's not overwritten
+- **Why**: If your `requirements.txt` has conflicting versions, this ensures LangGraph API stays intact
+
+---
+
+### 7. Cleanup Build Tools (Lines 37-41)
+```dockerfile
+RUN pip uninstall -y pip setuptools wheel
+RUN rm -rf /usr/local/lib/python*/site-packages/pip* ...
+RUN uv pip uninstall --system pip setuptools wheel && rm /usr/bin/uv /usr/bin/uvx
+```
+- **Purpose**: Removes all build tools to make the image smaller and more secure
+- **What gets removed**:
+  - `pip`, `setuptools`, `wheel` (Python build tools)
+  - `uv` and `uvx` (package installers)
+- **Why**: These tools aren't needed at runtime, only during build
+- **Security**: Smaller attack surface (can't install malicious packages at runtime)
+
+---
+
+### 8. Set Working Directory (Line 45)
+```dockerfile
+WORKDIR /deps/job_writer
+```
+- **Purpose**: Sets the default directory when the container starts
+- **Why**: Makes it easier to reference files relative to your project root
+
+---
+
+## How It Works at Runtime
+
+When this container runs:
+
+1. **LangServe starts automatically** (from base image)
+2. **Reads `LANGSERVE_GRAPHS`** environment variable
+3. **Imports your graphs** from the specified paths
+4. **Exposes REST API endpoints**:
+   - `POST /invoke/job_app_graph` - Main workflow
+   - `POST /invoke/research_workflow` - Research subgraph
+   - `POST /invoke/data_loading_workflow` - Data loading subgraph
+5. **Handles state management** automatically (checkpointing, persistence)
+
+## Example API Usage
+
+Once deployed, you can call your agent like this:
+
+```bash
+curl -X POST http://your-deployment/invoke/job_app_graph \
+  -H "Content-Type: application/json" \
+  -d '{
+    "resume_path": "...",
+    "job_description_source": "...",
+    "content": "cover_letter"
+  }'
+```
+
+## Key Points
+
+✅ **Optimized for LangGraph Cloud** - Uses official base image  
+✅ **Automatic API generation** - No need to write FastAPI code  
+✅ **State management** - Built-in checkpointing and persistence  
+✅ **Security** - Removes build tools from final image  
+✅ **Small image** - No-cache installs, no bytecode files  
+
+This is the **easiest deployment option** for LangGraph apps - just build and push this Docker image!
+

Dockerfile

@@ -34,6 +34,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 # Install Playwright system dependencies (after playwright package is installed)
 RUN playwright install-deps chromium
 
+<<<<<<< HEAD
 # Create user's cache directory for Playwright browsers (BEFORE installing browsers)
 # This ensures browsers are installed to the correct location that persists in the image
 RUN mkdir -p /home/hf_user/.cache/ms-playwright && \
@@ -47,6 +48,11 @@ RUN --mount=type=cache,target=/root/.cache/ms-playwright \
   playwright install chromium && \
   # Fix ownership after installation (browsers are installed as root)
   chown -R hf_user:hf_user /home/hf_user/.cache/ms-playwright
+=======
+# Install Playwright browser binaries (with cache mount)
+RUN --mount=type=cache,target=/root/.cache/ms-playwright \
+  playwright install chromium
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 
 # Create API directories and install langgraph-api as ROOT
 RUN mkdir -p /api/langgraph_api /api/langgraph_runtime /api/langgraph_license && \
@@ -81,9 +87,13 @@ ENV HOME=/home/hf_user \
   # Package-specific cache directories (for packages that don't fully respect XDG)
   TIKTOKEN_CACHE_DIR=/home/hf_user/.cache/tiktoken \
   HF_HOME=/home/hf_user/.cache/huggingface \
+<<<<<<< HEAD
   TORCH_HOME=/home/hf_user/.cache/torch \
   # Playwright browsers path (so it knows where to find browsers at runtime)
   PLAYWRIGHT_BROWSERS_PATH=/home/hf_user/.cache/ms-playwright
+=======
+  TORCH_HOME=/home/hf_user/.cache/torch
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 
 WORKDIR /deps/job_writer
 

docker-compose.override.example.yml

@@ -0,0 +1,21 @@
+# Example override file for local development
+# Copy this to docker-compose.override.yml to customize settings
+# docker-compose automatically loads override files
+
+version: "3.9"
+services:
+  redis:
+    # Override Redis port for local development
+    ports:
+      - "6380:6379"  # Use different port if 6379 is already in use
+
+  postgres:
+    # Override Postgres port for local development
+    ports:
+      - "5433:5432"  # Use different port if 5432 is already in use
+    environment:
+      # Override credentials for local dev
+      - POSTGRES_USER=dev_user
+      - POSTGRES_PASSWORD=dev_password
+      - POSTGRES_DB=job_app_dev
+

src/job_writing_agent/nodes/resume_loader.py

@@ -7,6 +7,7 @@ the resume file and returning the resume in the required format.
 """
 
 import logging
+<<<<<<< HEAD
 from pathlib import Path
 from typing import Any, Callable, Optional
 
@@ -14,6 +15,11 @@ from job_writing_agent.utils.document_processing import (
     get_resume as get_resume_docs,
     parse_resume,
 )
+=======
+from typing import Callable, Any, Optional
+
+from job_writing_agent.utils.document_processing import parse_resume
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 from job_writing_agent.utils.logging.logging_decorators import (
     log_async,
     log_errors,
@@ -59,8 +65,13 @@ class ResumeLoader:
         Parameters
         ----------
         resume_source: Any
+<<<<<<< HEAD
             Path, URL, or file-like object. Supports local paths, HTTP/HTTPS URLs,
             and HuggingFace Hub dataset references (e.g., "username/dataset::resume.pdf").
+=======
+            Path or file-like object accepted by the parser function.
+            Can be a file path, URL, or file-like object.
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 
         Returns
         -------
@@ -78,10 +89,14 @@ class ResumeLoader:
         resume_text = ""
         assert resume_source is not None, "resume_source cannot be None"
 
+<<<<<<< HEAD
         if isinstance(resume_source, (str, Path)):
             resume_chunks = await get_resume_docs(resume_source)
         else:
             resume_chunks = self._parser(resume_source)
+=======
+        resume_chunks = self._parser(resume_source)
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 
         for chunk in resume_chunks:
             if hasattr(chunk, "page_content") and chunk.page_content:

src/job_writing_agent/utils/document_processing.py

@@ -3,6 +3,7 @@ Document processing utilities for parsing resumes and job descriptions.
 """
 
 # Standard library imports
+<<<<<<< HEAD
 import asyncio
 import logging
 import os
@@ -10,12 +11,21 @@ import re
 import tempfile
 from pathlib import Path
 from typing import Optional
+=======
+import logging
+import os
+import re
+from pathlib import Path
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 from urllib.parse import urlparse
 
 # Third-party imports
 import dspy
+<<<<<<< HEAD
 import httpx
 from huggingface_hub import hf_hub_download
+=======
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 from langchain_community.document_loaders import PyPDFLoader, AsyncChromiumLoader
 from langchain_community.document_transformers import Html2TextTransformer
 from langchain_core.documents import Document
@@ -28,12 +38,16 @@ from pydantic import BaseModel, Field
 from typing_extensions import Any
 
 # Local imports
+<<<<<<< HEAD
 from .errors import (
     JobDescriptionParsingError,
     LLMProcessingError,
     ResumeDownloadError,
     URLExtractionError,
 )
+=======
+from .errors import JobDescriptionParsingError, LLMProcessingError, URLExtractionError
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -268,6 +282,7 @@ def _is_heading(line: str) -> bool:
     return line.isupper() and len(line.split()) <= 5 and not re.search(r"\d", line)
 
 
+<<<<<<< HEAD
 def _is_huggingface_hub_url(url: str) -> tuple[bool, Optional[str], Optional[str]]:
     """
     Detect if URL or string is a HuggingFace Hub reference and extract repo_id and filename.
@@ -424,6 +439,8 @@ async def download_file_from_url(
         raise ResumeDownloadError(f"Could not save file from {url}: {e}") from e
 
 
+=======
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 def parse_resume(file_path: str | Path) -> list[Document]:
     """
     Load a résumé from PDF or TXT file → list[Document] chunks
@@ -472,6 +489,7 @@ def parse_resume(file_path: str | Path) -> list[Document]:
     return chunks
 
 
+<<<<<<< HEAD
 async def get_resume(file_path_or_url: str | Path) -> list[Document]:
     """
     Load a résumé from a local file path or URL.
@@ -514,6 +532,8 @@ async def get_resume(file_path_or_url: str | Path) -> list[Document]:
     )
 
 
+=======
+>>>>>>> 64d45e6aae112e37b1f8aa7e8180959a0b9cac27
 async def get_job_description(file_path_or_url: str) -> Document:
     """Parse a job description from a file or URL into chunks.