feature: data uploading button, job descripiton fallback, requrements.txt

.env.example

@@ -1,9 +0,0 @@
-DATA_DIR=FOLDER PATH with your data (e.g. resumes, job descriptions, etc.)
-OPENROUTER_API_KEY=OPENROUTER API KEY
-CANDIDATE_NAME=YOUR NAME
-
-# Observability (optional) — omit or leave blank to skip tracing entirely.
-# Get your own keys at https://app.langfuse.com
-LANGFUSE_SECRET_KEY=
-LANGFUSE_PUBLIC_KEY=
-LANGFUSE_BASE_URL=

.gitignore

@@ -3,6 +3,7 @@ data/
 .venv/
 __pycache__/
 *.pyc
+.claude
 
 # LangGraph checkpoints
 checkpoints.sqlite

README.md

@@ -43,10 +43,10 @@ Then:
 pip install -r requirements.txt
 ```
 
-**2. Configure `.env`** in the project root:
+**2. Configure `.env`** in the project root (optional if you will paste your key into the UI):
 
 ```ini
-OPENROUTER_API_KEY=...            # required
+OPENROUTER_API_KEY=...            # optional; can also be entered in the UI
 CANDIDATE_NAME=Your Name        # used in the system prompt
 
 # Optional — Langfuse tracing. Tracing turns on only when both keys are present.
@@ -57,9 +57,8 @@ LANGFUSE_HOST=https://us.cloud.langfuse.com
 
 | Variable | Default | Purpose |
 |---|---|---|
-| `OPENROUTER_API_KEY` | — | Required. Startup fails without it. |
+| `OPENROUTER_API_KEY` | — | Optional. If omitted, paste a key into the app's OpenRouter API key panel. |
 | `CANDIDATE_NAME` | `the candidate` | Your name, used in the system prompt. |
-| `DATA_DIR` | `data` | Folder holding your profile documents. Relative paths resolve against the project root. |
 | `OPENROUTER_MODEL` | `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free` | OpenRouter model id. |
 | `LLM_TEMPERATURE` | `0.0` | Sampling temperature. |
 | `LLM_MAX_TOKENS` | `3000` | Response cap for ordinary chat. See the token budget note below. |
@@ -72,26 +71,17 @@ LANGFUSE_HOST=https://us.cloud.langfuse.com
 | `LANGFUSE_PUBLIC_KEY` / `LANGFUSE_SECRET_KEY` | — | Enable tracing when both are set. |
 | `LANGFUSE_HOST` (alias: `LANGFUSE_BASE_URL`) | `https://cloud.langfuse.com` | Langfuse region. Use `https://us.cloud.langfuse.com` if your keys are US. |
 
-**3. Add your documents.** Put your resume, project write-ups, and any other career documents
-in `data/`. PDFs must be converted to Markdown first — the app reads only `.md`:
+**3. Run**
 
 ```bash
-pip install -r requirements-ingest.txt   # docling, heavy; needed only for this step
-python pdf_2_markdown_converter.py
+python app.py                   # http://localhost:7860
 ```
 
-The converter reads and writes `data/` directly; it does not honour `DATA_DIR`. If you point
-`DATA_DIR` elsewhere, convert in `data/` first and move the `.md` files across.
-
-Startup fails if the directory is missing or holds no `.md` file, so do this before step 4.
+If you did not set `OPENROUTER_API_KEY` in `.env`, paste it into the **OpenRouter API key** panel and select **Connect key**. The key stays in server memory for that browser session and is not written to disk. Only enter a key when you trust the server running this app.
 
-**4. Run**
+Upload one or more PDF, DOCX, Markdown, or text files in **Your profile**. The app converts them to Markdown in memory and loads them into the profile pipeline; a later upload replaces the current profile. Uploads are not written to the project `data/` directory. Add a job description in **Target role** before chatting or using a skill button; requests without one do not call the model.
 
-```bash
-python app.py                   # http://localhost:7860
-```
-
-Paste a job description into the left panel, then chat or use the four skill buttons (Resume review, ATS score & keywords, Cover letter, Application email). Select
+Select
 **Stop** beside the message box to cancel a response that's being generated; any text already
 received remains in the conversation.
 
@@ -108,18 +98,19 @@ job-chat/
 ├── retrieval.py                 # Chunking and similarity search over the profile
 ├── embeddings.py                # fastembed wrapper
 ├── ats.py                       # ATS schema and score calculation
-├── dataloader.py                # Loads and concatenates the Markdown profile documents
+├── dataloader.py                # Converts uploads and formats Markdown profile documents
 ├── config.py                    # Environment settings with validation
 ├── observability.py             # Langfuse tracing (optional, fails open)
-├── pdf_2_markdown_converter.py  # One-off: PDF -> Markdown
-├── data/                        # Your documents (gitignored)
 ├── tests/                       # Unit tests; no API calls
 ├── .github/workflows/tests.yml  # CI: runs the suite on push and pull request
 ├── requirements.txt             # Runtime
-├── requirements-ingest.txt      # PDF conversion only
 └── requirements-dev.txt         # Tests (install on top of requirements.txt)
 ```
 
+Uploaded profile documents are held in server memory for the active Gradio session. Only upload
+personal documents to a deployment you trust. Hugging Face may also process temporary upload
+files as part of serving the app; consult the Space's privacy and storage settings.
+
 ## Graph structure
 
 A skill button routes on its `action` straight to that skill. Free-form chat is classified by a
@@ -197,7 +188,7 @@ python -m pytest tests/ -q
 Unit tests only — no API calls, no keys needed. They cover the ATS score arithmetic, config
 validation, document loading, chunking and retrieval, semantic routing, node selection, history
 trimming, temperature selection, and prompt templating. `tests/test_isolation.py` asserts the
-suite never touches your real credentials or your `data/` documents. CI runs the same command on
+suite never touches your real credentials or profile documents. CI runs the same command on
 every push to `main` and every pull request.
 
 ## Token budget

app.py

@@ -2,30 +2,99 @@ import logging
 import sys
 import uuid
 from functools import partial
+from pathlib import Path
 
 import gradio as gr
 from langchain_core.messages import AIMessage, HumanMessage
 
 from config import ConfigError, get_settings
-from graph import build_graph
+from dataloader import convert_uploaded_documents
+from graph import ATS_NODE, build_graph
 from observability import build_run_config, flush
-from graph import ATS_NODE
 from skills import ACTIONS
 
 logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
 logger = logging.getLogger("job-chat")
 
 try:
-    SETTINGS = get_settings()
-    GRAPH = build_graph()
-except (ConfigError, FileNotFoundError) as exc:
+    SETTINGS = get_settings(require_api_key=False)
+except ConfigError as exc:
     sys.exit(f"Startup failed: {exc}")
 
+SESSION_DATA = {}
+
 
 def new_thread_id():
     return str(uuid.uuid4())
 
 
+def discard_session_data(session_id):
+    SESSION_DATA.pop(session_id, None)
+
+
+def graph_for_session(session_id):
+    session = SESSION_DATA.get(session_id)
+    return session.get("graph") if session else None
+
+
+def connect_api_key(api_key, session_id):
+    api_key = (api_key or "").strip()
+    if not api_key:
+        return "", "Paste your OpenRouter API key to connect."
+
+    session = SESSION_DATA.setdefault(session_id, {})
+    session["api_key"] = api_key
+    profile_data = session.get("profile_data")
+    if not profile_data:
+        return "", "Key saved for this browser session. Upload your profile documents to continue."
+
+    try:
+        session["graph"] = build_graph(api_key=api_key, profile_data=profile_data)
+    except Exception as exc:
+        detail = str(exc).replace(api_key, "[redacted]")
+        logger.error("Could not initialize an OpenRouter graph: %s", detail)
+        return "", f"**Could not connect.** {detail}"
+
+    return "", "Key and profile ready for this browser session. Send a message to verify the key."
+
+
+def process_profile_upload(files, session_id):
+    if not files:
+        return "Choose one or more profile documents to upload."
+
+    try:
+        profile_data = convert_uploaded_documents(files)
+    except Exception as exc:
+        logger.error("Could not process profile upload: %s", exc)
+        return f"**Upload failed.** {exc}"
+
+    session = SESSION_DATA.setdefault(session_id, {})
+    session["profile_data"] = profile_data
+    session["graph"] = None
+    api_key = session.get("api_key") or SETTINGS.openrouter_api_key
+
+    if not api_key:
+        return "Profile converted to Markdown and held for this session. Connect your OpenRouter key to continue."
+
+    try:
+        session["graph"] = build_graph(api_key=api_key, profile_data=profile_data)
+    except Exception as exc:
+        detail = str(exc).replace(api_key, "[redacted]")
+        logger.error("Could not initialize the uploaded profile: %s", detail)
+        return f"**Profile converted, but setup failed.** {detail}"
+
+    names = ", ".join(Path(file_path).name for file_path in files)
+    return f"**Profile ready.** Converted and loaded: {names}"
+
+
+def clear_profile(session_id):
+    session = SESSION_DATA.get(session_id)
+    if session:
+        session.pop("profile_data", None)
+        session.pop("graph", None)
+    return None, "Uploaded profile cleared from this session."
+
+
 def jd_status(job_description):
     if job_description and job_description.strip():
         return f"**Loaded** — {len(job_description.split())} words"
@@ -43,14 +112,21 @@ def show_action_label(label, chat_history):
     return chat_history + [{"role": "user", "content": f"**{label}**"}]
 
 
-def run_action(key, chat_history, job_description, thread_id):
+def run_action(key, chat_history, job_description, thread_id, session_id):
     _, instruction = ACTIONS[key]
     yield from stream_response(
-        chat_history, job_description, thread_id, model_query=instruction, action=key
+        chat_history,
+        job_description,
+        thread_id,
+        model_query=instruction,
+        action=key,
+        session_id=session_id,
     )
 
 
-def stream_response(chat_history, job_description, thread_id, model_query=None, action=""):
+def stream_response(
+    chat_history, job_description, thread_id, session_id=None, model_query=None, action=""
+):
     """Stream the assistant reply for the last user message.
 
     model_query lets a skill button send its instruction to the model while the
@@ -64,6 +140,23 @@ def stream_response(chat_history, job_description, thread_id, model_query=None,
         return
 
     job_description = (job_description or "").strip()
+    if not job_description:
+        chat_history = chat_history + [{
+            "role": "assistant",
+            "content": "Paste a job description in the **Target role** panel before asking a question or using a skill.",
+        }]
+        yield chat_history
+        return
+
+    graph = graph_for_session(session_id)
+    if graph is None:
+        chat_history = chat_history + [{
+            "role": "assistant",
+            "content": "Upload your profile documents and connect an OpenRouter API key before chatting.",
+        }]
+        yield chat_history
+        return
+
     state = {
         "messages": [HumanMessage(content=model_query or chat_history[-1]["content"])],
         "job_description": job_description,
@@ -78,7 +171,7 @@ def stream_response(chat_history, job_description, thread_id, model_query=None,
             yield chat_history
 
         streamed = False
-        for mode, chunk in GRAPH.stream(state, config, stream_mode=["messages", "updates"]):
+        for mode, chunk in graph.stream(state, config, stream_mode=["messages", "updates"]):
             if mode == "messages":
                 message, meta = chunk
                 # The ATS node's model call emits structured-output fragments, not prose.
@@ -114,12 +207,39 @@ def stream_response(chat_history, job_description, thread_id, model_query=None,
 
 with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as demo:
     thread_id = gr.State(new_thread_id)
+    session_id = gr.State(new_thread_id, delete_callback=discard_session_data)
 
     gr.Markdown("## Job chat")
     gr.Markdown("Ask about your background, draft interview answers, or test your fit against a role.")
+    with gr.Accordion(
+        "OpenRouter API key", open=not bool(SETTINGS.openrouter_api_key)
+    ):
+        api_key_box = gr.Textbox(
+            label="Paste your OpenRouter API key",
+            placeholder="sk-or-v1-…",
+            type="password",
+            show_label=True,
+        )
+        connect_key_btn = gr.Button("Connect key")
+        key_status = gr.Markdown(
+            "Using the server-configured key."
+            if SETTINGS.openrouter_api_key
+            else "Your key is kept in server memory for this browser session and is not written to disk."
+        )
 
     with gr.Row(equal_height=False):
         with gr.Column(scale=1):
+            gr.Markdown("### Your profile")
+            profile_upload = gr.File(
+                label="Upload profile documents",
+                file_count="multiple",
+                file_types=[".pdf", ".docx", ".md", ".txt"],
+                type="filepath",
+            )
+            profile_status = gr.Markdown(
+                "Upload PDF, DOCX, Markdown, or text files. A new upload replaces the previous profile."
+            )
+            clear_profile_btn = gr.Button("Clear uploaded profile")
             gr.Markdown("### Target role")
             jd_box = gr.Textbox(
                 lines=18,
@@ -150,6 +270,21 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
 
     jd_box.change(jd_status, inputs=jd_box, outputs=jd_state)
     clear_jd_btn.click(lambda: "", outputs=jd_box)
+    connect_key_btn.click(
+        connect_api_key,
+        inputs=[api_key_box, session_id],
+        outputs=[api_key_box, key_status],
+    )
+    profile_upload.upload(
+        process_profile_upload,
+        inputs=[profile_upload, session_id],
+        outputs=profile_status,
+    )
+    clear_profile_btn.click(
+        clear_profile,
+        inputs=session_id,
+        outputs=[profile_upload, profile_status],
+    )
 
     # A new thread id starts a fresh checkpointed conversation; the old one stays on disk.
     clear_chat_btn.click(lambda: ([], new_thread_id()), outputs=[chatbot, thread_id])
@@ -163,7 +298,7 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
         queue=False,
     ).then(
         stream_response,
-        inputs=[chatbot, jd_box, thread_id],
+        inputs=[chatbot, jd_box, thread_id, session_id],
         outputs=chatbot,
     ))
 
@@ -175,7 +310,7 @@ with gr.Blocks(title="job-chat", fill_height=True, analytics_enabled=False) as d
             queue=False,
         ).then(
             partial(run_action, key),
-            inputs=[chatbot, jd_box, thread_id],
+            inputs=[chatbot, jd_box, thread_id, session_id],
             outputs=chatbot,
         ))
 

config.py

@@ -23,7 +23,6 @@ DEFAULT_DRAFTING_TEMPERATURE = 0.4
 DEFAULT_MAX_TOKENS = 20000
 # Skill output (cover letters, reviews, ATS reports) gets its own response cap.
 DEFAULT_SKILL_MAX_TOKENS = 6500
-DEFAULT_DATA_DIR = "data"
 DEFAULT_LANGFUSE_HOST = "https://cloud.langfuse.com"
 DEFAULT_CHECKPOINT_DB = "checkpoints.sqlite"
 # Turns of conversation replayed to the model. Older turns stay in the
@@ -42,7 +41,6 @@ class ConfigError(RuntimeError):
 class Settings:
     openrouter_api_key: str
     candidate_name: str
-    data_dir: Path
     model: str
     temperature: float
     drafting_temperature: float
@@ -82,36 +80,15 @@ def _get_int(name, default):
         raise ConfigError(f"{name} must be an integer, got {raw!r}")
 
 
-def _resolve_data_dir():
-    raw = os.getenv("DATA_DIR", "").strip() or DEFAULT_DATA_DIR
-    data_dir = Path(raw)
-    if not data_dir.is_absolute():
-        data_dir = PROJECT_ROOT / data_dir
-
-    if not data_dir.is_dir():
-        raise ConfigError(
-            f"DATA_DIR does not exist: {data_dir}\n"
-            f"Set DATA_DIR in .env to the folder holding your profile documents, "
-            f"or remove it to use the default ({PROJECT_ROOT / DEFAULT_DATA_DIR})."
-        )
-    if not any(data_dir.glob("*.md")):
-        raise ConfigError(
-            f"No .md documents found in {data_dir}\n"
-            f"Run pdf_2_markdown_converter.py to convert your PDFs first."
-        )
-    return data_dir
-
-
-@lru_cache(maxsize=1)
-def get_settings() -> Settings:
+@lru_cache(maxsize=2)
+def get_settings(require_api_key=True) -> Settings:
     api_key = os.getenv("OPENROUTER_API_KEY", "").strip()
-    if not api_key:
+    if require_api_key and not api_key:
         raise ConfigError("OPENROUTER_API_KEY is not set. Add it to your .env file.")
 
     return Settings(
         openrouter_api_key=api_key,
         candidate_name=os.getenv("CANDIDATE_NAME", "").strip() or "the candidate",
-        data_dir=_resolve_data_dir(),
         model=os.getenv("OPENROUTER_MODEL", "").strip() or DEFAULT_MODEL,
         temperature=_get_float("LLM_TEMPERATURE", DEFAULT_TEMPERATURE),
         drafting_temperature=_get_float("LLM_DRAFTING_TEMPERATURE", DEFAULT_DRAFTING_TEMPERATURE),

dataloader.py

@@ -1,23 +1,44 @@
 from pathlib import Path
 
 SEPARATOR = "\n\n" + "-" * 60 + "\n\n"
+SUPPORTED_UPLOAD_EXTENSIONS = {".pdf", ".docx", ".md", ".txt"}
 
 
-class ProfileLoader:
-    """Loads the candidate's markdown profile documents into a single context string."""
+def format_documents(documents):
+    """Combine named Markdown strings into the profile context."""
+    sections = [
+        f"# Source: {Path(name).stem}\n\n{content.strip()}"
+        for name, content in documents
+        if content and content.strip()
+    ]
+    if not sections:
+        raise ValueError("The uploaded documents contain no readable text.")
+    return SEPARATOR.join(sections)
 
-    def __init__(self, data_dir):
-        self.data_dir = Path(data_dir)
 
-    def load_and_format_markdown(self):
-        # Sorted so document order — and therefore model output — is reproducible.
-        md_files = sorted(self.data_dir.glob("*.md"))
-        if not md_files:
-            raise FileNotFoundError(f"No .md documents found in {self.data_dir}")
+def convert_uploaded_documents(files):
+    """Convert supported uploaded files to one Markdown profile in memory."""
+    documents = []
+    converter = None
 
-        sections = []
-        for md_file in md_files:
-            content = md_file.read_text(encoding="utf-8").strip()
-            sections.append(f"# Source: {md_file.stem}\n\n{content}")
+    for file_path in files or []:
+        path = Path(file_path)
+        extension = path.suffix.lower()
+        if extension not in SUPPORTED_UPLOAD_EXTENSIONS:
+            supported = ", ".join(sorted(SUPPORTED_UPLOAD_EXTENSIONS))
+            raise ValueError(
+                f"Unsupported file type '{extension or '(none)'}' for {path.name}. "
+                f"Upload files with these extensions: {supported}."
+            )
 
-        return SEPARATOR.join(sections)
+        if extension in {".md", ".txt"}:
+            content = path.read_text(encoding="utf-8-sig")
+        else:
+            if converter is None:
+                from markitdown import MarkItDown
+
+                converter = MarkItDown()
+            content = converter.convert(str(path)).markdown
+        documents.append((path.name, content))
+
+    return format_documents(documents)

embeddings.py

@@ -14,7 +14,7 @@ from config import get_settings
 def _model():
     from fastembed import TextEmbedding
 
-    return TextEmbedding(get_settings().embedding_model)
+    return TextEmbedding(get_settings(require_api_key=False).embedding_model)
 
 
 def embed(texts) -> np.ndarray:

graph.py

@@ -19,8 +19,7 @@ from langgraph.graph.message import add_messages
 
 import router as router_module
 from ats import ATSAnalysis, format_ats_report
-from config import OPENROUTER_BASE_URL, get_settings
-from dataloader import ProfileLoader
+from config import ConfigError, OPENROUTER_BASE_URL, get_settings
 from embeddings import embed
 from prompts import (
     NO_JD_PLACEHOLDER,
@@ -96,10 +95,13 @@ def route_action(state, semantic_router=None) -> str:
     return NODE_BY_ROUTE[semantic_router.route(query)]
 
 
-def build_llm(temperature=None, max_tokens=None):
-    settings = get_settings()
+def build_llm(temperature=None, max_tokens=None, api_key=None):
+    settings = get_settings(require_api_key=False)
+    api_key = api_key or settings.openrouter_api_key
+    if not api_key:
+        raise ConfigError("An OpenRouter API key is required to build the model.")
     return ChatOpenAI(
-        api_key=settings.openrouter_api_key,
+        api_key=api_key,
         base_url=OPENROUTER_BASE_URL,
         model=settings.model,
         temperature=settings.temperature if temperature is None else temperature,
@@ -107,24 +109,31 @@ def build_llm(temperature=None, max_tokens=None):
     )
 
 
-def build_graph():
-    settings = get_settings()
-    profile_data = ProfileLoader(settings.data_dir).load_and_format_markdown()
+def build_graph(api_key=None, profile_data=None):
+    settings = get_settings(require_api_key=False)
+    api_key = api_key or settings.openrouter_api_key
+    if not api_key:
+        raise ConfigError("An OpenRouter API key is required to build the graph.")
+    if not profile_data or not profile_data.strip():
+        raise ConfigError("Upload profile documents before building the graph.")
     prompt = build_qa_prompt()
-    llm = build_llm()
+    llm = build_llm(api_key=api_key)
     chain = prompt | llm
     skill_prompt = build_skill_prompt()
     skill_chains = {
         key: skill_prompt | build_llm(
             settings.drafting_temperature if key in DRAFTING_SKILLS else None,
             settings.skill_max_tokens,
+            api_key=api_key,
         )
         for key in SKILLS
         if key != "ats"
     }
     rag_chain = build_rag_prompt() | llm
     trivial_chain = build_trivial_prompt() | llm
-    structured_llm = build_llm(max_tokens=settings.skill_max_tokens).with_structured_output(ATSAnalysis)
+    structured_llm = build_llm(
+        max_tokens=settings.skill_max_tokens, api_key=api_key
+    ).with_structured_output(ATSAnalysis)
 
     index = ProfileIndex(chunk_documents(profile_data), embed)
     semantic_router = SemanticRouter(embed)

observability.py

@@ -21,7 +21,7 @@ def _init():
         return
     _initialised = True
 
-    settings = get_settings()
+    settings = get_settings(require_api_key=False)
     if not settings.tracing_enabled:
         logger.info("Langfuse tracing disabled (LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY not set).")
         return

pdf_2_markdown_converter.py

@@ -1,15 +0,0 @@
-from markitdown import MarkItDown
-import os 
-from tqdm import tqdm
-    
-md_converter = MarkItDown()
-
-home_dir = "C:\\Users\\Jasmi\\OneDrive\\Desktop\\job"
-file_names = ["Haider_Ali_AI_engineer_resume.pdf", "Projects.pdf", "Volunteer Experiences.pdf"]
-
-for file_name in file_names:
-    file_path = os.path.join(home_dir, file_name)
-    result = md_converter.convert(file_path)
-
-    with open(os.path.join(home_dir, "job-chat", "data", file_name.replace(".pdf", ".md")), "w", encoding="utf-8") as f:
-        f.write(result.markdown)

prompts.py

@@ -39,7 +39,7 @@ RAG_SYSTEM_PROMPT = """You are {candidate_name}'s assistant. Answer the user's n
 def render_system_prompt(context_text, job_description) -> str:
     """The system prompt as plain text, for paths that bypass the chat template."""
     return QA_SYSTEM_PROMPT.format(
-        candidate_name=get_settings().candidate_name,
+        candidate_name=get_settings(require_api_key=False).candidate_name,
         context_text=context_text,
         job_description=job_description or NO_JD_PLACEHOLDER,
     )
@@ -50,7 +50,7 @@ def _chat_prompt(system_text) -> ChatPromptTemplate:
         ("system", system_text),
         MessagesPlaceholder("history"),
         ("user", "{user_query}"),
-    ]).partial(candidate_name=get_settings().candidate_name)
+    ]).partial(candidate_name=get_settings(require_api_key=False).candidate_name)
 
 
 def build_qa_prompt() -> ChatPromptTemplate:
@@ -98,7 +98,7 @@ SKILL_SYSTEM_PROMPT = """You are the interview-preparation assistant for {candid
 def render_skill_prompt(skill_text, context_text, job_description) -> str:
     """The skill system prompt as plain text, for paths that bypass the chat template."""
     return SKILL_SYSTEM_PROMPT.format(
-        candidate_name=get_settings().candidate_name,
+        candidate_name=get_settings(require_api_key=False).candidate_name,
         skill_text=skill_text,
         context_text=context_text,
         job_description=job_description or NO_JD_PLACEHOLDER,

requirements-ingest.txt

@@ -1,4 +0,0 @@
-# Only needed to run pdf_2_markdown_converter.py (PDF -> Markdown).
-# Pulls in torch and other heavy deps; the chat app does not need these.
-docling==2.118.0
-tqdm==4.69.0

requirements.txt

@@ -6,6 +6,7 @@ langgraph==1.2.10
 langgraph-checkpoint-sqlite==3.1.1
 langfuse==4.14.3
 python-dotenv==1.2.2
+markitdown[docx,pdf]==0.1.9
 
 # Makes Python trust the OS certificate store. Required on networks that do
 # TLS inspection (corporate proxy / antivirus); harmless elsewhere.

tests/conftest.py

@@ -5,23 +5,15 @@ the suite never reads the developer's real .env or personal documents and runs
 identically on a clean CI machine.
 """
 
-import atexit
 import os
-import shutil
 import sys
-import tempfile
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
-_FIXTURE_DIR = tempfile.mkdtemp(prefix="job-chat-tests-")
-(Path(_FIXTURE_DIR) / "fixture.md").write_text("# Fixture profile", encoding="utf-8")
-atexit.register(shutil.rmtree, _FIXTURE_DIR, True)
-
 # load_dotenv() does not override variables that are already set, so these win
 # over any real .env on a developer machine.
 os.environ["OPENROUTER_API_KEY"] = "test-key-not-used"
-os.environ["DATA_DIR"] = _FIXTURE_DIR
 os.environ["CANDIDATE_NAME"] = "Test Candidate"
 # Set to empty rather than deleted: load_dotenv() skips keys already present, so
 # an empty value keeps real Langfuse credentials out and stops the suite emitting

tests/test_app.py

@@ -0,0 +1,42 @@
+import app
+
+
+def test_chat_without_job_description_does_not_access_the_graph(monkeypatch):
+    def graph_must_not_be_requested(_session_id):
+        raise AssertionError("A model graph must not be accessed without a job description.")
+
+    monkeypatch.setattr(app, "graph_for_session", graph_must_not_be_requested)
+
+    result = list(app.stream_response(
+        [{"role": "user", "content": "Tell me about my experience"}],
+        " \n ",
+        "thread-id",
+        "session-id",
+    ))
+
+    assert len(result) == 1
+    assert "Paste a job description" in result[0][-1]["content"]
+
+
+def test_upload_builds_a_per_session_graph(monkeypatch, tmp_path):
+    markdown_file = tmp_path / "resume.md"
+    markdown_file.write_text("# Resume", encoding="utf-8")
+    build_calls = []
+    monkeypatch.setattr(app, "convert_uploaded_documents", lambda _files: "# Profile")
+    monkeypatch.setattr(
+        app,
+        "build_graph",
+        lambda **kwargs: build_calls.append(kwargs) or "compiled-graph",
+    )
+    monkeypatch.setitem(app.SESSION_DATA, "upload-test-session", {})
+
+    status = app.process_profile_upload(
+        [str(markdown_file)], "upload-test-session"
+    )
+
+    assert "Profile ready" in status
+    assert build_calls == [{
+        "api_key": app.SETTINGS.openrouter_api_key,
+        "profile_data": "# Profile",
+    }]
+    assert app.graph_for_session("upload-test-session") == "compiled-graph"

tests/test_config.py

@@ -12,17 +12,10 @@ def clear_settings_cache():
 
 
 @pytest.fixture
-def data_dir(tmp_path):
-    (tmp_path / "resume.md").write_text("# Resume", encoding="utf-8")
-    return tmp_path
-
-
-@pytest.fixture
-def base_env(monkeypatch, data_dir):
+def base_env(monkeypatch):
     monkeypatch.setenv("OPENROUTER_API_KEY", "test-key")
-    monkeypatch.setenv("DATA_DIR", str(data_dir))
     for name in ("OPENROUTER_MODEL", "LLM_TEMPERATURE", "LLM_MAX_TOKENS", "SKILL_MAX_TOKENS", "MAX_HISTORY_TURNS",
-                 "CANDIDATE_NAME", "LANGFUSE_HOST", "LANGFUSE_BASE_URL",
+                 "CANDIDATE_NAME", "DATA_DIR", "LANGFUSE_HOST", "LANGFUSE_BASE_URL",
                  "LANGFUSE_PUBLIC_KEY", "LANGFUSE_SECRET_KEY"):
         monkeypatch.delenv(name, raising=False)
 
@@ -33,18 +26,12 @@ def test_missing_api_key_is_rejected(base_env, monkeypatch):
         get_settings()
 
 
-def test_nonexistent_data_dir_is_rejected(base_env, monkeypatch, tmp_path):
-    monkeypatch.setenv("DATA_DIR", str(tmp_path / "nope"))
-    with pytest.raises(ConfigError, match="DATA_DIR does not exist"):
-        get_settings()
+def test_api_key_can_be_supplied_later_by_the_ui(base_env, monkeypatch):
+    monkeypatch.delenv("OPENROUTER_API_KEY")
 
+    settings = get_settings(require_api_key=False)
 
-def test_data_dir_without_markdown_is_rejected(base_env, monkeypatch, tmp_path):
-    empty = tmp_path / "empty"
-    empty.mkdir()
-    monkeypatch.setenv("DATA_DIR", str(empty))
-    with pytest.raises(ConfigError, match="No .md documents"):
-        get_settings()
+    assert settings.openrouter_api_key == ""
 
 
 @pytest.mark.parametrize("var", ["LLM_TEMPERATURE", "LLM_MAX_TOKENS", "SKILL_MAX_TOKENS", "MAX_HISTORY_TURNS"])
@@ -75,16 +62,12 @@ def test_overrides_are_read_from_the_environment(base_env, monkeypatch):
     assert settings.max_history_turns == 3
 
 
-def test_relative_data_dir_resolves_against_the_project_root(base_env, monkeypatch, tmp_path):
-    """A relative DATA_DIR must not depend on the process working directory."""
-    project_root = tmp_path / "project"
-    (project_root / "docs").mkdir(parents=True)
-    (project_root / "docs" / "resume.md").write_text("# Resume", encoding="utf-8")
+def test_settings_do_not_require_a_data_directory(base_env, monkeypatch, tmp_path):
+    monkeypatch.setenv("DATA_DIR", str(tmp_path / "missing"))
 
-    monkeypatch.setattr(config, "PROJECT_ROOT", project_root)
-    monkeypatch.setenv("DATA_DIR", "docs")
+    settings = get_settings()
 
-    assert get_settings().data_dir == project_root / "docs"
+    assert not hasattr(settings, "data_dir")
 
 
 class TestLangfuseHost:

tests/test_dataloader.py

@@ -1,49 +1,44 @@
 import pytest
 
-from dataloader import ProfileLoader
+from dataloader import convert_uploaded_documents
 
 
-@pytest.fixture
-def docs(tmp_path):
-    (tmp_path / "resume.md").write_text("Resume body", encoding="utf-8")
-    (tmp_path / "projects.md").write_text("Projects body", encoding="utf-8")
-    (tmp_path / "ignored.txt").write_text("not markdown", encoding="utf-8")
-    return tmp_path
+def test_uploaded_markdown_and_text_are_formatted_without_disk_output(tmp_path):
+    markdown = tmp_path / "resume.md"
+    text = tmp_path / "projects.txt"
+    markdown.write_text("# Resume", encoding="utf-8")
+    text.write_text("Project work", encoding="utf-8")
 
+    profile = convert_uploaded_documents([str(markdown), str(text)])
 
-def test_loads_every_markdown_file(docs):
-    content = ProfileLoader(docs).load_and_format_markdown()
-    assert "Resume body" in content
-    assert "Projects body" in content
+    assert "# Source: resume" in profile
+    assert "# Resume" in profile
+    assert "# Source: projects" in profile
+    assert "Project work" in profile
 
 
-def test_ignores_non_markdown_files(docs):
-    assert "not markdown" not in ProfileLoader(docs).load_and_format_markdown()
+def test_uploaded_pdf_is_converted_to_markdown(tmp_path, monkeypatch):
+    import sys
+    from types import SimpleNamespace
 
+    pdf = tmp_path / "resume.pdf"
+    pdf.write_bytes(b"fake pdf")
 
-def test_documents_are_labelled_with_their_source(docs):
-    content = ProfileLoader(docs).load_and_format_markdown()
-    assert "# Source: resume" in content
-    assert "# Source: projects" in content
+    class FakeConverter:
+        def convert(self, path):
+            assert path == str(pdf)
+            return SimpleNamespace(markdown="# Converted resume")
 
+    monkeypatch.setitem(
+        sys.modules, "markitdown", SimpleNamespace(MarkItDown=FakeConverter)
+    )
 
-def test_order_is_sorted_and_therefore_reproducible(docs):
-    """Unsorted glob order made identical questions produce different answers."""
-    content = ProfileLoader(docs).load_and_format_markdown()
-    assert content.index("# Source: projects") < content.index("# Source: resume")
-    assert content == ProfileLoader(docs).load_and_format_markdown()
+    assert "# Converted resume" in convert_uploaded_documents([str(pdf)])
 
 
-def test_empty_directory_raises(tmp_path):
-    with pytest.raises(FileNotFoundError, match="No .md documents"):
-        ProfileLoader(tmp_path).load_and_format_markdown()
+def test_uploaded_unsupported_file_type_is_rejected(tmp_path):
+    unsupported = tmp_path / "profile.exe"
+    unsupported.write_text("not a document", encoding="utf-8")
 
-
-def test_missing_directory_raises(tmp_path):
-    with pytest.raises(FileNotFoundError):
-        ProfileLoader(tmp_path / "absent").load_and_format_markdown()
-
-
-def test_unicode_survives_the_round_trip(tmp_path):
-    (tmp_path / "doc.md").write_text("Café — naïve — 日本語", encoding="utf-8")
-    assert "Café — naïve — 日本語" in ProfileLoader(tmp_path).load_and_format_markdown()
+    with pytest.raises(ValueError, match="Unsupported file type"):
+        convert_uploaded_documents([str(unsupported)])

tests/test_graph.py

@@ -3,7 +3,8 @@
 import pytest
 from langchain_core.messages import AIMessage, HumanMessage, trim_messages
 
-from graph import latest_text, route_action
+from config import ConfigError
+from graph import build_graph, latest_text, route_action
 
 
 @pytest.mark.parametrize(
@@ -26,6 +27,11 @@ def test_missing_action_key_falls_back_to_chat():
     assert route_action({}) == "answer"
 
 
+def test_graph_rejects_empty_profile_before_model_setup():
+    with pytest.raises(ConfigError, match="Upload profile documents"):
+        build_graph(api_key="test-key", profile_data="  ")
+
+
 class StubRouter:
     def __init__(self, decision):
         self.decision = decision

tests/test_isolation.py

@@ -21,7 +21,5 @@ def test_the_real_openrouter_key_is_not_used():
     assert get_settings().openrouter_api_key == "test-key-not-used"
 
 
-def test_personal_documents_are_not_read():
-    data_dir = get_settings().data_dir
-    assert data_dir.name != "data"
-    assert [p.name for p in data_dir.glob("*.md")] == ["fixture.md"]
+def test_profile_documents_are_not_loaded_during_startup():
+    assert not hasattr(get_settings(), "data_dir")

tests/test_temperature.py

@@ -31,6 +31,16 @@ def test_build_llm_accepts_an_override():
     assert build_llm(0.4).temperature == 0.4
 
 
+def test_build_llm_accepts_a_ui_key_without_an_environment_key(monkeypatch):
+    monkeypatch.delenv("OPENROUTER_API_KEY")
+    get_settings.cache_clear()
+    try:
+        llm = build_llm(api_key="ui-key")
+        assert llm.openai_api_key.get_secret_value() == "ui-key"
+    finally:
+        get_settings.cache_clear()
+
+
 def test_drafting_temperature_is_configurable(monkeypatch):
     monkeypatch.setenv("LLM_DRAFTING_TEMPERATURE", "0.9")
     get_settings.cache_clear()