Added mongodb store dependency for Agent Memory

DEPLOYMENT_GUIDE.md

@@ -1,303 +0,0 @@
-# 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

@@ -1,147 +0,0 @@
-# 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!
-

RESUME_STORAGE_GUIDE.md

@@ -1,239 +0,0 @@
-# Resume Storage Options for HF Spaces Deployment
-
-This guide explains different ways to store and access your resume file for the deployed LangGraph application on HuggingFace Spaces.
-
-## Problem
-
-HuggingFace Spaces doesn't allow binary files (PDFs) in git repositories. We removed `resume.pdf` from git, but the workflow needs access to it.
-
-## Solution Options
-
-### ✅ Option 1: URL Support (Easiest - Already Implemented!)
-
-**Status:** ✅ **Code updated - now supports URLs!**
-
-You can now provide a resume URL instead of a file path. The code will automatically download it.
-
-**Supported URL formats:**
-- `https://example.com/resume.pdf` - Direct HTTP/HTTPS links
-- `https://github.com/username/repo/raw/main/resume.pdf` - GitHub raw files
-- `https://drive.google.com/uc?export=download&id=FILE_ID` - Google Drive (public)
-- Any publicly accessible URL
-
-**How to use:**
-
-1. **Upload resume to a public location:**
-   - GitHub: Upload to a repo and use the "raw" file URL
-   - Google Drive: Make file public, get shareable link
-   - Dropbox: Get public link
-   - Any web server or CDN
-
-2. **Use the URL in your API call:**
-   ```json
-   {
-     "assistant_id": "job_app_graph",
-     "input": {
-       "resume_path": "https://github.com/username/repo/raw/main/resume.pdf",
-       "job_description_source": "https://example.com/job",
-       "content_category": "cover_letter"
-     }
-   }
-   ```
-
-**Pros:**
-- ✅ No code changes needed (already implemented)
-- ✅ Works with any public URL
-- ✅ No additional services required
-- ✅ Easy to update (just replace the file at the URL)
-
-**Cons:**
-- ⚠️ File must be publicly accessible
-- ⚠️ Requires internet connection to download
-
----
-
-### Option 2: HuggingFace Hub Dataset (Recommended for Production)
-
-Store your resume in HF Hub as a dataset - native integration with HF Spaces.
-
-**Steps:**
-
-1. **Install HF Hub CLI:**
-   ```bash
-   pip install huggingface_hub
-   ```
-
-2. **Login to HF:**
-   ```bash
-   huggingface-cli login
-   ```
-
-3. **Create a dataset and upload resume:**
-   ```bash
-   # Create dataset (one-time)
-   huggingface-cli repo create resume-dataset --type dataset
-   
-   # Upload resume
-   huggingface-cli upload Rishabh2095/resume-dataset resume.pdf resume.pdf
-   ```
-
-4. **Access in code (add to workflow):**
-   ```python
-   from huggingface_hub import hf_hub_download
-   import tempfile
-   
-   # Download resume from HF Hub
-   resume_path = hf_hub_download(
-       repo_id="Rishabh2095/resume-dataset",
-       filename="resume.pdf",
-       cache_dir="/tmp"
-   )
-   ```
-
-5. **Use in API call:**
-   ```json
-   {
-     "assistant_id": "job_app_graph",
-     "input": {
-       "resume_path": "/tmp/resume.pdf",  # After downloading from HF Hub
-       "job_description_source": "https://example.com/job",
-       "content_category": "cover_letter"
-     }
-   }
-   ```
-
-**Pros:**
-- ✅ Native HF integration
-- ✅ Private datasets supported
-- ✅ Version control for resume
-- ✅ No external dependencies
-
-**Cons:**
-- ⚠️ Requires code modification to download from HF Hub
-- ⚠️ Slight overhead for downloading
-
----
-
-### Option 3: Object Storage (S3, GCS, Azure Blob)
-
-Use cloud object storage for production scalability.
-
-**Example: AWS S3**
-
-1. **Upload to S3:**
-   ```bash
-   aws s3 cp resume.pdf s3://your-bucket/resume.pdf --acl public-read
-   ```
-
-2. **Use public URL:**
-   ```json
-   {
-     "resume_path": "https://your-bucket.s3.amazonaws.com/resume.pdf"
-   }
-   ```
-
-**For private S3 (requires credentials):**
-- Add AWS credentials as HF Space secrets
-- Use `boto3` to download in code
-
-**Pros:**
-- ✅ Scalable and reliable
-- ✅ Supports private files with auth
-- ✅ Industry standard
-
-**Cons:**
-- ⚠️ Requires cloud account setup
-- ⚠️ May incur costs
-- ⚠️ More complex setup
-
----
-
-### Option 4: HF Spaces Persistent Storage
-
-HF Spaces provides `/tmp` directory that persists across restarts.
-
-**Steps:**
-
-1. **Upload file via API or during build:**
-   - Add file to Docker image (but this increases image size)
-   - Or download during container startup
-
-2. **Use in code:**
-   ```python
-   # In your workflow initialization
-   DEFAULT_RESUME_PATH = "/tmp/resume.pdf"
-   ```
-
-**Pros:**
-- ✅ No external dependencies
-- ✅ Fast access (local file)
-
-**Cons:**
-- ⚠️ File must be in Docker image (increases size)
-- ⚠️ Not easily updatable without rebuild
-
----
-
-### Option 5: Environment Variable with URL
-
-Store resume URL as an HF Space secret.
-
-**Steps:**
-
-1. **Add to HF Space Secrets:**
-   - Go to Space Settings → Variables and secrets
-   - Add: `RESUME_URL=https://example.com/resume.pdf`
-
-2. **Use in code:**
-   ```python
-   import os
-   resume_path = os.getenv("RESUME_URL", "default_path_or_url")
-   ```
-
-**Pros:**
-- ✅ Easy to update (change secret, no code deploy)
-- ✅ Can point to any URL
-- ✅ Works with Option 1 (URL support)
-
-**Cons:**
-- ⚠️ Requires code modification to read env var
-
----
-
-## Recommended Approach
-
-**For Quick Start:** Use **Option 1 (URL Support)** - just upload your resume to GitHub, Google Drive, or any public URL and use that URL in your API calls.
-
-**For Production:** Use **Option 2 (HF Hub Dataset)** - native integration, private support, version control.
-
-## Implementation Status
-
-- ✅ **URL Support:** Implemented in `parse_resume()` function
-- ⏳ **HF Hub Integration:** Can be added if needed
-- ⏳ **Environment Variable:** Can be added if needed
-
-## Testing
-
-Test with a public resume URL:
-
-```powershell
-# Test with GitHub raw file URL
-$body = @{
-    assistant_id = "job_app_graph"
-    input = @{
-        resume_path = "https://github.com/username/repo/raw/main/resume.pdf"
-        job_description_source = "https://example.com/job"
-        content_category = "cover_letter"
-    }
-} | ConvertTo-Json
-
-Invoke-RestMethod -Uri "https://rishabh2095-agentworkflowjobapplications.hf.space/runs/wait" `
-    -Method POST -Body $body -ContentType "application/json"
-```
-
-## Next Steps
-
-1. Upload your resume to a public location (GitHub, Google Drive, etc.)
-2. Get the public URL
-3. Use that URL in your API calls as `resume_path`
-4. The code will automatically download and process it!

docker-compose.override.example.yml

@@ -1,21 +0,0 @@
-# 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
-

pyproject.toml

@@ -119,6 +119,7 @@ dependencies = [
     "langgraph-prebuilt",
     "langgraph-runtime-inmem==0.14.1",
     "langgraph-sdk==0.2.9",
+    "langgraph-store-mongodb>=0.1.1",
     "langsmith>=0.6.3",
     "lazy-object-proxy==1.12.0",
     "litellm==1.77.7",

src/job_writing_agent/langgraph_init.py

@@ -1,4 +0,0 @@
-from .workflow import JobWorkflow
-
-
-job_app_graph= JobWorkflow().compile()