Update recursion limit in job workflow and replace LLM model references with Google Gemma. Add new data loading and research subgraph modules for modularity

src/job_writing_agent/agents/nodes.py

@@ -41,7 +41,7 @@ def create_draft(state: ResearchState) -> ResultState:
     # Create LLM inside function (lazy initialization)
     llm_provider = LLMFactory()
     llm = llm_provider.create_langchain(
-        "mistralai/devstral-2512:free",
+        "google/gemma-3-27b-it:free",
         provider="openrouter",
         temperature=0.3,
     )
@@ -139,7 +139,7 @@ def critique_draft(state: ResultState) -> ResultState:
         # Create LLM inside function (lazy initialization)
         llm_provider = LLMFactory()
         llm = llm_provider.create_langchain(
-            "mistralai/devstral-2512:free",
+            "google/gemma-3-27b-it:free",
             provider="openrouter",
             temperature=0.3,
         )
@@ -269,7 +269,7 @@ def finalize_document(state: ResultState) -> ResultState:
     # Create LLM inside function (lazy initialization)
     llm_provider = LLMFactory()
     llm = llm_provider.create_langchain(
-        "mistralai/devstral-2512:free",
+        "google/gemma-3-27b-it:free",
         provider="openrouter",
         temperature=0.3,
     )

src/job_writing_agent/graph/background_research_subgraph.py

@@ -0,0 +1,342 @@
+# research_workflow.py
+"""Research workflow for company information gathering and filtering."""
+
+# Standard library imports
+import asyncio
+import json
+import logging
+from typing import Any, Dict, cast
+
+# Third-party imports
+import dspy
+from langgraph.graph import StateGraph
+
+# Local imports
+from job_writing_agent.agents.output_schema import (
+    CompanyResearchDataSummarizationSchema,
+)
+from job_writing_agent.classes.classes import ResearchState, CompanyResearchData
+from job_writing_agent.tools.SearchTool import (
+    TavilyResearchTool,
+    filter_research_results_by_relevance,
+)
+from job_writing_agent.utils.llm_provider_factory import LLMFactory
+
+logger = logging.getLogger(__name__)
+
+# Configuration
+MAX_RETRIES = 3
+RETRY_DELAY = 2  # seconds
+QUERY_TIMEOUT = 30  # seconds
+EVAL_TIMEOUT = 15  # seconds per evaluation
+
+
+def validate_research_inputs(state: ResearchState) -> tuple[bool, str, str]:
+    """
+    Validate that required inputs are present in research state.
+
+    Args:
+        state: Current research workflow state
+
+    Returns:
+        Tuple of (is_valid, company_name, job_description)
+    """
+    try:
+        # Safe dictionary access with fallbacks
+        company_research_data = state.company_research_data or CompanyResearchData()
+        company_name = company_research_data.company_name
+        job_description = company_research_data.job_description
+
+        if not company_name or not company_name.strip():
+            logger.error("Company name is missing or empty")
+            return False, "", ""
+
+        if not job_description or not job_description.strip():
+            logger.error("Job description is missing or empty")
+            return False, "", ""
+
+        return True, company_name.strip(), job_description.strip()
+
+    except (TypeError, AttributeError) as e:
+        logger.error(f"Invalid state structure: {e}")
+        return False, "", ""
+
+
+def parse_dspy_queries_with_fallback(
+    raw_queries: dict[str, Any], company_name: str
+) -> dict[str, str]:
+    """
+    Parse DSPy query output with multiple fallback strategies.
+    Returns a dict of query_id -> query_string.
+    """
+    try:
+        # Try to extract search_queries field
+        if isinstance(raw_queries, dict) and "search_queries" in raw_queries:
+            queries_data = raw_queries["search_queries"]
+
+            # If it's a JSON string, parse it
+            if isinstance(queries_data, str):
+                try:
+                    queries_data = json.loads(queries_data)
+                except json.JSONDecodeError as e:
+                    logger.warning(f"JSON decode failed: {e}. Using fallback queries.")
+                    return get_fallback_queries(company_name)
+
+            # Extract query strings
+            if isinstance(queries_data, dict):
+                parsed = {}
+                for key, value in queries_data.items():
+                    if isinstance(value, str):
+                        parsed[key] = value
+                    elif isinstance(value, list) and len(value) > 0:
+                        parsed[key] = str(value[0])
+
+                if parsed:
+                    return parsed
+
+        # If we reach here, parsing failed
+        logger.warning("Could not parse DSPy queries. Using fallback.")
+        return get_fallback_queries(company_name)
+
+    except Exception as e:
+        logger.error(f"Error parsing DSPy queries: {e}. Using fallback.")
+        return get_fallback_queries(company_name)
+
+
+def get_fallback_queries(company_name: str) -> dict[str, str]:
+    """
+    Generate basic fallback queries when DSPy fails.
+    """
+    return {
+        "query1": f"{company_name} company culture and values",
+        "query2": f"{company_name} recent news and achievements",
+        "query3": f"{company_name} mission statement and goals",
+    }
+
+
+def company_research_data_summary(state: ResearchState) -> dict[str, Any]:
+    """
+    Summarize the filtered research data into a concise summary.
+
+    Replaces the raw tavily_search results with a summarized version using LLM.
+
+    Args:
+        state: Current research state with search results
+
+    Returns:
+        Updated state with research summary
+    """
+    try:
+        # Update current node
+        updated_state = {
+            **state.__dict__,
+            "current_node": "company_research_data_summary",
+        }
+
+        # Extract the current research data with safe access
+        company_research_data = state.company_research_data or CompanyResearchData()
+        tavily_search_data = company_research_data.tavily_search
+
+        # If no research data, skip summarization
+        if not tavily_search_data or len(tavily_search_data) == 0:
+            logger.warning("No research data to summarize. Skipping summarization.")
+            return updated_state
+
+        logger.info(f"Summarizing {len(tavily_search_data)} research result sets...")
+
+        # Create DSPy summarization chain
+        company_research_data_summarization = dspy.ChainOfThought(
+            CompanyResearchDataSummarizationSchema
+        )
+
+        # Initialize LLM provider
+
+        llm_provider = LLMFactory()
+        llm = llm_provider.create_dspy(
+            model="liquid/lfm-2.5-1.2b-instruct:free",
+            provider="openrouter",
+            temperature=0.3,
+        )
+
+        # Generate summary using DSPy
+        with dspy.context(lm=llm, adapter=dspy.JSONAdapter()):
+            response = company_research_data_summarization(
+                company_research_data=company_research_data
+            )
+        # Extract the summary from the response with safe access
+        summary_json_str = ""
+        if hasattr(response, "company_research_data_summary"):
+            summary_json_str = response.company_research_data_summary
+        elif isinstance(response, dict):
+            summary_json_str = response.get("company_research_data_summary", "")
+        else:
+            logger.error(
+                f"Unexpected response format from summarization: {type(response)}"
+            )
+            return updated_state
+
+        # Update state with summary using safe dictionary operations
+        updated_company_research_data = {**company_research_data.__dict__}
+        updated_company_research_data["company_research_data_summary"] = (
+            summary_json_str
+        )
+        updated_state["company_research_data"] = CompanyResearchData(
+            **updated_company_research_data
+        )
+
+        return updated_state
+
+    except Exception as e:
+        logger.error(f"Error in company_research_data_summary: {e}", exc_info=True)
+        # Return minimal update so we don't reference updated_state (may be undefined).
+        return {"current_node": "company_research_data_summary"}
+
+
+async def research_company_with_retry(state: ResearchState) -> dict[str, Any]:
+    """
+    Research company with retry logic and timeouts.
+    """
+    state.current_node = "research_company"
+
+    # Validate inputs
+    is_valid, company_name, job_description = validate_research_inputs(state)
+
+    if not is_valid:
+        logger.error("Invalid inputs for research. Skipping research phase.")
+        cr = state.company_research_data or CompanyResearchData()
+        return {
+            "company_research_data": cr.model_copy(update={"tavily_search": []}),
+            "attempted_search_queries": [],
+            "current_node": "research_company",
+        }
+
+    logger.info(f"Researching company: {company_name}")
+
+    # Try with retries
+    for attempt in range(MAX_RETRIES):
+        try:
+            # Create tool instance
+            tavily_search = TavilyResearchTool(
+                job_description=job_description, company_name=company_name
+            )
+
+            # Generate queries with timeout
+            queries_task = asyncio.create_task(
+                asyncio.to_thread(tavily_search.create_tavily_queries)
+            )
+
+            try:
+                raw_queries = await asyncio.wait_for(
+                    queries_task, timeout=QUERY_TIMEOUT
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    f"Query generation timed out (attempt {attempt + 1}/{MAX_RETRIES})"
+                )
+                if attempt < MAX_RETRIES - 1:
+                    await asyncio.sleep(RETRY_DELAY)
+                    continue
+                else:
+                    raise
+
+            # Parse queries with fallback
+            # Convert DSPy Prediction to dict if needed
+            if hasattr(raw_queries, "dict"):
+                raw_queries_dict = cast(Dict[str, Any], raw_queries.dict())
+            elif hasattr(raw_queries, "__dict__"):
+                raw_queries_dict = cast(Dict[str, Any], raw_queries.__dict__)
+            elif isinstance(raw_queries, dict):
+                raw_queries_dict = cast(Dict[str, Any], raw_queries)
+            else:
+                raw_queries_dict = cast(Dict[str, Any], dict(raw_queries))
+
+            queries = parse_dspy_queries_with_fallback(raw_queries_dict, company_name)
+
+            if not queries:
+                logger.warning("No valid queries generated")
+                queries = get_fallback_queries(company_name)
+
+            logger.info(
+                f"Generated {len(queries)} search queries: {list(queries.keys())}"
+            )
+
+            # Perform searches with timeout
+            search_task = asyncio.create_task(
+                asyncio.to_thread(tavily_search.tavily_search_company, queries)
+            )
+
+            try:
+                search_results = await asyncio.wait_for(
+                    search_task, timeout=QUERY_TIMEOUT * len(queries)
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    f"Search timed out (attempt {attempt + 1}/{MAX_RETRIES})"
+                )
+                if attempt < MAX_RETRIES - 1:
+                    await asyncio.sleep(RETRY_DELAY)
+                    continue
+                else:
+                    raise
+
+            # Validate results
+            if not isinstance(search_results, list):
+                logger.warning(f"Invalid search results type: {type(search_results)}")
+                search_results = []
+
+            if len(search_results) == 0:
+                logger.warning("No search results returned")
+
+            # Return partial state update with CompanyResearchData (typed), not raw dict.
+            cr = state.company_research_data or CompanyResearchData()
+            return {
+                "company_research_data": cr.model_copy(update={"tavily_search": search_results}),
+                "attempted_search_queries": list(queries.values()),
+                "current_node": "research_company",
+            }
+
+        except Exception as e:
+            logger.error(
+                f"Error in research_company (attempt {attempt + 1}/{MAX_RETRIES}): {e}",
+                exc_info=True,
+            )
+
+            if attempt < MAX_RETRIES - 1:
+                await asyncio.sleep(RETRY_DELAY * (attempt + 1))  # Exponential backoff
+            else:
+                logger.error("All retry attempts exhausted. Using empty results.")
+                cr = state.company_research_data or CompanyResearchData()
+                return {
+                    "company_research_data": cr.model_copy(update={"tavily_search": []}),
+                    "attempted_search_queries": [],
+                    "current_node": "research_company",
+                }
+
+    cr = state.company_research_data or CompanyResearchData()
+    return {
+        "company_research_data": cr,
+        "attempted_search_queries": [],
+        "current_node": "research_company",
+    }
+
+
+# Create research subgraph
+research_subgraph = StateGraph(ResearchState)
+
+# Add research subgraph nodes
+research_subgraph.add_node("research_company", research_company_with_retry)
+research_subgraph.add_node("relevance_filter", filter_research_results_by_relevance)
+research_subgraph.add_node(
+    "company_research_data_summary", company_research_data_summary
+)
+
+# Set entry and finish points
+research_subgraph.set_entry_point("research_company")
+research_subgraph.set_finish_point("company_research_data_summary")
+
+# Add research subgraph edges
+research_subgraph.add_edge("research_company", "relevance_filter")
+research_subgraph.add_edge("relevance_filter", "company_research_data_summary")
+
+# Compile research subgraph
+background_research_workflow = research_subgraph.compile()

src/job_writing_agent/graph/data_loading_subgraph.py

@@ -0,0 +1,342 @@
+# -*- coding: utf-8 -*-
+"""
+Data Loading Subgraph Module
+
+This module defines the data loading subgraph, including all node
+functions and the subgraph definition. It uses the separate loader classes
+(ResumeLoader, JobDescriptionLoader, SystemInitializer) following the
+Single Responsibility Principle.
+
+Advanced patterns used:
+- **Decorators**: @log_async (cross-cutting logging), @retry_async_load (tenacity
+  retry for I/O nodes). Stack order: retry innermost, log_async outermost so we
+  log once per logical call and retry inside.
+- **Type hints**: Literal for conditional edge targets (type-safe routing),
+  StateUpdate alias for partial state dicts.
+- **functools.wraps**: Preserved in log_async and in custom retry decorator
+  so __name__ and docstrings are correct for debugging and LangGraph.
+"""
+
+import logging
+from typing import Any, Literal, Callable
+from functools import wraps
+
+from langgraph.graph import StateGraph
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from job_writing_agent.classes import (
+    DataLoadState,
+    CompanyResearchData,
+    DataLoadingNodes,
+    AgentWorkflowNodes,
+)
+from job_writing_agent.nodes.graph_interrupt import GraphInterrupt
+from job_writing_agent.nodes.resume_loader import ResumeLoader
+from job_writing_agent.nodes.job_description_loader import JobDescriptionLoader
+from job_writing_agent.nodes.system_initializer import SystemInitializer
+from job_writing_agent.utils.document_processing import analyze_candidate_job_fit
+from job_writing_agent.utils.logging.logging_decorators import log_async
+
+logger = logging.getLogger(__name__)
+
+# Type alias for LangGraph partial state updates (nodes return dicts that get merged).
+StateUpdate = dict[str, Any]
+
+# Retry config for I/O-bound load nodes (resume, job description).
+_LOAD_RETRY_ATTEMPTS = 3
+_LOAD_RETRY_MIN_WAIT = 1
+_LOAD_RETRY_MAX_WAIT = 10
+
+
+def _get_cr(state: DataLoadState) -> CompanyResearchData:
+    """Safe access to company_research_data; returns empty instance if missing."""
+    return state.company_research_data or CompanyResearchData()
+
+
+def retry_async_load(func: Callable) -> Callable:
+    """
+    Decorator: retry async load functions with exponential backoff.
+
+    Uses tenacity for retries. Apply below @log_async so we log once per
+    logical invocation; retries happen inside. Preserves __name__ etc. via wraps.
+    """
+
+    @retry(
+        stop=stop_after_attempt(_LOAD_RETRY_ATTEMPTS),
+        wait=wait_exponential(
+            multiplier=1, min=_LOAD_RETRY_MIN_WAIT, max=_LOAD_RETRY_MAX_WAIT
+        ),
+        retry=retry_if_exception_type((OSError, ConnectionError, TimeoutError)),
+        reraise=True,
+    )
+    @wraps(func)
+    async def wrapper(state: DataLoadState) -> StateUpdate:
+        return await func(state)
+
+    return wrapper
+
+
+graph_interrupt = GraphInterrupt()
+
+
+# ============================================================================
+# Data Loading Subgraph Node Functions
+# ============================================================================
+
+
+@log_async
+async def set_agent_system_message_node(state: DataLoadState) -> StateUpdate:
+    """
+    Node function to initialize system message in workflow state.
+
+    This node wraps the SystemInitializer.set_agent_system_message method
+    for use in the LangGraph workflow.
+
+    Parameters
+    ----------
+    state: DataLoadState
+        Current workflow state.
+
+    Returns
+    -------
+    StateUpdate
+        Partial state update with system message added to messages list.
+    """
+    initializer = SystemInitializer()
+    return await initializer.set_agent_system_message(state)
+
+
+@log_async
+@retry_async_load
+async def load_resume_node(state: DataLoadState) -> StateUpdate:
+    """
+    Load the resume from the configured source (file path). Runs before job description parsing.
+
+    Returns only the resume data; LangGraph merges this update with state.
+    Retries on OSError/ConnectionError/TimeoutError (tenacity).
+
+    Parameters
+    ----------
+    state: DataLoadState
+        Current workflow state containing resume_path.
+
+    Returns
+    -------
+    StateUpdate
+        Partial state update with resume data in company_research_data.
+    """
+    resume_src = state.workflow_inputs.resume_file_path_
+    if not resume_src:
+        resume_text = ""
+    else:
+        loader = ResumeLoader()
+        resume_text = await loader.load_resume(resume_src)
+    logger.info(f"Resume loaded: {len(resume_text)} characters")
+    cr = _get_cr(state)
+    return {"company_research_data": cr.model_copy(update={"resume": resume_text})}
+
+
+def prompt_user_for_resume_node(state: DataLoadState) -> StateUpdate:
+    """
+    Prompt user to provide resume manually via chat (paste text).
+
+    Used when resume extraction failed or no path was given. The workflow
+    pauses; the frontend shows the interrupt payload so the user can paste
+    their resume. The client resumes with Command(resume=user_input). If the
+    user sends empty input, we return {} so the router sends execution back here.
+    """
+    logger.info("Resume missing or empty, prompting user to paste resume via chat")
+    return graph_interrupt.request_input_for_field(
+        state, "resume", "Please paste your resume in text format:", "resume"
+    )
+
+
+def prompt_user_for_job_description_node(state: DataLoadState) -> StateUpdate:
+    """
+    Prompt user to provide job description manually via chat (paste text).
+
+    Used when job description extraction failed or no URL was given. The workflow
+    pauses; the frontend shows the interrupt so the user can paste the job
+    description. The client resumes with Command(job_description=user_input).
+    If the user sends empty input, we return {} so the router sends execution back here.
+    """
+    logger.info("Job description missing or empty, prompting user to paste via chat")
+    return graph_interrupt.request_input_for_field(
+        state, "job_description", "Please paste the job description:", "job description"
+    )
+
+
+def route_after_resume_load(
+    state: DataLoadState,
+) -> Literal["prompt_user_for_resume", "load_job_description"]:
+    """After load_resume: if resume is empty, go to prompt_user_for_resume; else go to load_job_description."""
+    cr = state.company_research_data
+    resume = (cr.resume if cr else "") or ""
+    resume = str(resume).strip()
+    if not resume:
+        logger.info("Resume is empty, routing to prompt_user_for_resume")
+        return "prompt_user_for_resume"
+    logger.info("Resume is present, routing to load_job_description")
+    return "load_job_description"
+
+
+def route_after_job_load(
+    state: DataLoadState,
+) -> Literal["prompt_user_for_job_description", "candidate_job_fit_analysis"]:
+    """After load_job_description: if job_description is empty, go to prompt_user_for_job_description; else go to candidate_job_fit_analysis."""
+    cr = state.company_research_data
+    job_desc = (cr.job_description if cr else "") or ""
+    job_desc = str(job_desc).strip()
+    if not job_desc:
+        logger.info(
+            "Job description is empty, routing to prompt_user_for_job_description"
+        )
+        return "prompt_user_for_job_description"
+    logger.info("Job description is present, routing to candidate_job_fit_analysis")
+    return "candidate_job_fit_analysis"
+
+
+@log_async
+@retry_async_load
+async def load_job_description_node(state: DataLoadState) -> StateUpdate:
+    """
+    Load the job description from the configured URL. Runs after resume is loaded or provided via interrupt.
+
+    Returns job description and company name in company_research_data; LangGraph merges this update with state.
+    Retries on OSError/ConnectionError/TimeoutError (tenacity).
+
+    Parameters
+    ----------
+    state: DataLoadState
+        Current workflow state containing job_description_url_.
+
+    Returns
+    -------
+    StateUpdate
+        Partial state update with job description and company name in company_research_data.
+    """
+    jd_src = state.workflow_inputs.job_description_url_
+    if not jd_src:
+        job_text = ""
+        company_name = ""
+    else:
+        loader = JobDescriptionLoader()
+        job_text, company_name = await loader.load_job_description(jd_src)
+    cr = _get_cr(state)
+    resume_text = cr.resume or ""
+
+    logger.info(
+        f"Job description loaded: {len(job_text)} characters, company: {company_name}"
+    )
+    return {
+        "company_research_data": cr.model_copy(
+            update={
+                "resume": resume_text,
+                "job_description": job_text,
+                "company_name": company_name,
+            }
+        )
+    }
+
+
+@log_async
+async def candidate_job_fit_analysis_node(state: DataLoadState) -> StateUpdate:
+    """
+    Analyze candidate-job fit using DSPy after resume and job description are loaded.
+
+    Uses the resume and job description to generate actionable insights
+    for downstream content generation (cover letter, bullets, LinkedIn note).
+
+    Parameters
+    ----------
+    state: DataLoadState
+        Current workflow state with resume and job description loaded.
+
+    Returns
+    -------
+    StateUpdate
+        Partial state update with candidate_job_fit_analysis in company_research_data
+        and next_node set to NodeName.RESEARCH for main graph routing.
+    """
+    cr = _get_cr(state)
+    resume_text = cr.resume or ""
+    job_description = cr.job_description or ""
+    company_name = cr.company_name or ""
+
+    # Validate inputs (should always pass due to routing, but log if not)
+    if not resume_text.strip():
+        logger.warning("Resume is empty in candidate_job_fit_analysis_node")
+    if not job_description.strip():
+        logger.warning("Job description is empty in candidate_job_fit_analysis_node")
+
+    analysis = await analyze_candidate_job_fit(
+        resume_text=resume_text,
+        job_description=job_description,
+        company_name=company_name,
+    )
+
+    logger.info("Candidate-job fit analysis node completed")
+
+    return {
+        "company_research_data": cr.model_copy(
+            update={"candidate_job_fit_analysis": analysis}
+        ),
+        "next_node": AgentWorkflowNodes.RESEARCH,
+    }
+
+
+# ============================================================================
+# Data Loading Subgraph Definition
+# ============================================================================
+
+N = DataLoadingNodes  # Shorthand for graph construction
+
+data_loading_subgraph = StateGraph(DataLoadState)
+
+data_loading_subgraph.add_node(
+    N.SET_AGENT_SYSTEM_MESSAGE.value, set_agent_system_message_node
+)
+data_loading_subgraph.add_node(N.LOAD_RESUME.value, load_resume_node)
+data_loading_subgraph.add_node(N.LOAD_JOB_DESCRIPTION.value, load_job_description_node)
+data_loading_subgraph.add_node(
+    N.PROMPT_USER_FOR_RESUME.value, prompt_user_for_resume_node
+)
+data_loading_subgraph.add_node(
+    N.PROMPT_USER_FOR_JOB_DESCRIPTION.value, prompt_user_for_job_description_node
+)
+data_loading_subgraph.add_node(
+    N.CANDIDATE_JOB_FIT_ANALYSIS.value, candidate_job_fit_analysis_node
+)
+
+data_loading_subgraph.set_entry_point(N.SET_AGENT_SYSTEM_MESSAGE.value)
+data_loading_subgraph.set_finish_point(N.CANDIDATE_JOB_FIT_ANALYSIS.value)
+data_loading_subgraph.add_edge(N.SET_AGENT_SYSTEM_MESSAGE.value, N.LOAD_RESUME.value)
+data_loading_subgraph.add_conditional_edges(
+    N.LOAD_RESUME.value,
+    route_after_resume_load,
+    {
+        N.PROMPT_USER_FOR_RESUME.value: N.PROMPT_USER_FOR_RESUME.value,
+        N.LOAD_JOB_DESCRIPTION.value: N.LOAD_JOB_DESCRIPTION.value,
+    },
+)
+data_loading_subgraph.add_edge(
+    N.PROMPT_USER_FOR_RESUME.value, N.LOAD_JOB_DESCRIPTION.value
+)
+data_loading_subgraph.add_conditional_edges(
+    N.LOAD_JOB_DESCRIPTION.value,
+    route_after_job_load,
+    {
+        N.PROMPT_USER_FOR_JOB_DESCRIPTION.value: N.PROMPT_USER_FOR_JOB_DESCRIPTION.value,
+        N.CANDIDATE_JOB_FIT_ANALYSIS.value: N.CANDIDATE_JOB_FIT_ANALYSIS.value,
+    },
+)
+data_loading_subgraph.add_edge(
+    N.PROMPT_USER_FOR_JOB_DESCRIPTION.value, N.CANDIDATE_JOB_FIT_ANALYSIS.value
+)
+
+data_loading_workflow = data_loading_subgraph.compile(name="Data Load Subgraph")

src/job_writing_agent/nodes/research_workflow.py

@@ -150,7 +150,7 @@ def company_research_data_summary(state: ResearchState) -> ResearchState:
 
         llm_provider = LLMFactory()
         llm = llm_provider.create_dspy(
-            model="mistralai/devstral-2512:free",
+            model="google/gemma-3-27b-it:free",
             provider="openrouter",
             temperature=0.3,
         )

src/job_writing_agent/tools/SearchTool.py

@@ -37,7 +37,7 @@ class TavilyResearchTool:
         job_description,
         company_name,
         max_results=5,
-        model_name="mistralai/devstral-2512:free",
+        model_name="google/gemma-3-2google/gemma-3-27b-it:free7b-it:free",
     ):
         # Create LLM inside __init__ (lazy initialization)
         llm_provider = LLMFactory()

src/job_writing_agent/workflow.py

@@ -155,7 +155,7 @@ class JobWorkflow:
                 "session_id": thread_id,
             },
             "tags": ["job-application-workflow", self.content],
-            "recursion_limit": 2,
+            "recursion_limit": 10,
         }
 
     @log_execution