Add agents directory with citation, draft, outline, and topic modules

agents/__init__.py

@@ -0,0 +1 @@
+# Agents package for Research Paper Generator

agents/citation_formatter.py

@@ -0,0 +1,53 @@
+"""
+LangChain LLMChain for generating bibliography from research notes and draft.
+"""
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import OpenAI
+
+from config import get_openai_api_key
+
+# Prompt template for bibliography generation
+BIBLIOGRAPHY_PROMPT = """
+You are an expert academic writer. Given research notes and a draft, generate a bibliography in APA format with a maximum of 10 references.
+
+Research notes:
+{research_notes}
+
+Draft:
+{draft}
+
+Instructions:
+- Analyze the research notes and draft to identify the most important sources and references
+- Extract information about studies, papers, authors, and findings mentioned
+- Create proper APA format citations for each source
+- Include author names, publication years, titles, and sources where possible
+- If specific details are missing, create reasonable citations based on the content
+- Limit the bibliography to a maximum of 10 references
+- Choose the most relevant and important sources only
+- Number the references if they are cited in the draft with [1], [2], etc.
+
+Example format:
+[1] Smith, J., & Johnson, A. (2023). Title of the study. Journal Name, 45(2), 123-145.
+
+Bibliography (APA format, maximum 10 references):
+"""
+
+def get_bibliography_chain():
+    """
+    Returns a LangChain LLMChain for bibliography generation.
+    """
+    prompt = PromptTemplate(
+        input_variables=["research_notes", "draft"],
+        template=BIBLIOGRAPHY_PROMPT
+    )
+    
+    # Always enable streaming in the LLM - callbacks will be passed during execution
+    llm = OpenAI(
+        temperature=0.1, 
+        openai_api_key=get_openai_api_key(),
+        streaming=True  # Always enable streaming
+    )
+    
+    return LLMChain(llm=llm, prompt=prompt, output_key="bibliography")

agents/draft_writer.py

@@ -0,0 +1,242 @@
+# agents/draft_writer.py
+
+from typing import Any, Dict, Generator
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import OpenAI
+
+from config import get_openai_api_key
+from streaming_config import get_chunk_size, is_yield_enabled
+
+"""
+LangChain LLMChain for writing a draft based on the outline and research notes with yield support.
+"""
+DRAFT_WRITER_PROMPT = """
+You are an expert academic writer. Given a research paper outline and research notes, write a comprehensive draft of the paper. Use clear academic language and expand on each section of the outline.
+
+Outline:
+{outline}
+
+Research notes:
+{research_notes}
+
+Instructions:
+- Write a comprehensive draft that fully develops each section of the outline
+- Use section headings and include inline citations like [1], [2] where appropriate
+- Do not include a bibliography section
+- Ensure the draft is complete and covers all points from the outline
+
+
+Draft:
+"""
+
+def get_draft_writer_chain():
+    """
+    Returns a LangChain LLMChain for draft writing.
+    """
+    prompt = PromptTemplate(
+        input_variables=["outline", "research_notes"],
+        template=DRAFT_WRITER_PROMPT
+    )
+    
+    # Always enable streaming in the LLM - callbacks will be passed during execution
+    llm = OpenAI(
+        temperature=0.3, 
+        openai_api_key=get_openai_api_key(),
+        streaming=True  # Always enable streaming
+    )
+    
+    return LLMChain(llm=llm, prompt=prompt, output_key="draft")
+
+def yield_draft_writing(outline: str, research_notes: str, preset: str = None) -> Generator[str, None, None]:
+    """
+    Yield draft writing results progressively
+    
+    Args:
+        outline: The research paper outline
+        research_notes: The research notes
+        preset: Optional streaming preset
+        
+    Yields:
+        str: Progressive draft content
+    """
+    if not is_yield_enabled(preset):
+        # Fallback to non-yield processing
+        chain = get_draft_writer_chain()
+        result = chain.run(outline=outline, research_notes=research_notes)
+        yield result
+        return
+    
+    try:
+        # Import required modules
+        from langchain.prompts import PromptTemplate
+        from langchain_openai import ChatOpenAI
+
+        from config import get_openai_api_key
+
+        # Create prompt template
+        prompt = PromptTemplate(
+            input_variables=["outline", "research_notes"],
+            template=DRAFT_WRITER_PROMPT
+        )
+        
+        # Create LLM with streaming
+        llm = ChatOpenAI(
+            temperature=0.3, 
+            openai_api_key=get_openai_api_key(),
+            streaming=True
+        )
+        
+        # Format the prompt
+        formatted_prompt = prompt.format(outline=outline, research_notes=research_notes)
+        
+        # Get chunk size for this step
+        chunk_size = get_chunk_size("draft_writer", preset)
+        
+        # Call LLM and yield results progressively
+        result = llm.invoke(formatted_prompt)
+        content = result.content
+        
+        # Yield content in chunks
+        for i in range(0, len(content), chunk_size):
+            chunk = content[i:i + chunk_size]
+            yield chunk
+            
+    except Exception as e:
+        yield f"Error in draft writing: {str(e)}"
+
+def yield_draft_by_sections(outline: str, research_notes: str) -> Generator[str, None, None]:
+    """
+    Yield draft writing organized by sections
+    
+    Args:
+        outline: The research paper outline
+        research_notes: The research notes
+        
+    Yields:
+        str: Progressive draft content by section
+    """
+    # Parse outline to extract sections
+    sections = []
+    lines = outline.split('\n')
+    current_section = ""
+    
+    for line in lines:
+        line = line.strip()
+        if line and (line.startswith('#') or line.startswith('1.') or line.startswith('2.') or 
+                    line.startswith('3.') or line.startswith('4.') or line.startswith('5.')):
+            current_section = line
+            sections.append(current_section)
+    
+    if not sections:
+        # Fallback to single section
+        yield "Writing complete draft..."
+        for chunk in yield_draft_writing(outline, research_notes):
+            yield chunk
+        return
+    
+    yield f"Writing draft with {len(sections)} sections..."
+    
+    for i, section in enumerate(sections, 1):
+        yield f"\n--- Section {i}: {section} ---"
+        
+        # Create section-specific prompt
+        section_prompt = f"""
+        Write the content for this specific section of the research paper:
+        
+        Section: {section}
+        Full Outline: {outline}
+        Research Notes: {research_notes}
+        
+        Focus on developing this section comprehensively.
+        """
+        
+        # Process section with yield
+        for chunk in yield_draft_writing(section_prompt, research_notes):
+            yield chunk
+        
+        yield f"\n--- Section {i} Complete ---\n"
+
+def yield_draft_with_style(outline: str, research_notes: str, style: str = "academic") -> Generator[str, None, None]:
+    """
+    Yield draft writing with specific style using yield generators
+    
+    Args:
+        outline: The research paper outline
+        research_notes: The research notes
+        style: Writing style (academic, technical, accessible, etc.)
+        
+    Yields:
+        str: Progressive draft content with specified style
+    """
+    style_instructions = {
+        "academic": "Use formal academic language with proper citations and scholarly tone.",
+        "technical": "Focus on technical details and methodology with precise terminology.",
+        "accessible": "Use clear, accessible language suitable for broader audiences.",
+        "concise": "Write in a concise, direct manner with minimal elaboration."
+    }
+    
+    style_instruction = style_instructions.get(style, style_instructions["academic"])
+    
+    yield f"Writing draft in {style} style..."
+    
+    # Create style-enhanced prompt
+    enhanced_prompt = f"""
+    You are an expert academic writer. Given a research paper outline and research notes, write a comprehensive draft of the paper.
+    
+    Style requirement: {style_instruction}
+    
+    Outline:
+    {outline}
+    
+    Research notes:
+    {research_notes}
+    
+    Instructions:
+    - Write a comprehensive draft that fully develops each section of the outline
+    - Use section headings and include inline citations like [1], [2] where appropriate
+    - Do not include a bibliography section
+    - Ensure the draft is complete and covers all points from the outline
+    - Follow the specified style: {style}
+    
+    Draft:
+    """
+    
+    # Yield the enhanced draft writing
+    for chunk in yield_draft_writing(enhanced_prompt, ""):
+        yield chunk
+
+def process_draft_with_revisions(outline: str, research_notes: str, revisions: list = None) -> Generator[str, None, None]:
+    """
+    Process draft writing with optional revision requests using yield generators
+    
+    Args:
+        outline: The research paper outline
+        research_notes: The research notes
+        revisions: Optional list of revision requests
+        
+    Yields:
+        str: Progressive draft content with revisions
+    """
+    if revisions:
+        yield f"Applying {len(revisions)} revision requests..."
+        
+        # Apply revisions to the prompt
+        revision_text = "\n".join([f"- {rev}" for rev in revisions])
+        enhanced_prompt = f"""
+        Outline: {outline}
+        Research notes: {research_notes}
+        
+        Revision requests:
+        {revision_text}
+        
+        Please incorporate these revision requests into the draft.
+        """
+    else:
+        enhanced_prompt = f"Outline: {outline}\nResearch notes: {research_notes}"
+    
+    # Yield the enhanced draft writing
+    for chunk in yield_draft_writing(enhanced_prompt, ""):
+        yield chunk

agents/outline_builder.py

@@ -0,0 +1,127 @@
+"""
+LangChain LLMChain for building research paper outlines.
+"""
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import OpenAI
+
+from config import get_openai_api_key
+
+# Prompt template for initial outline building
+OUTLINE_BUILDER_PROMPT = """
+You are an expert academic writer. Given a refined research topic and research notes, create a comprehensive outline for a research paper.
+
+Refined topic: {refined_topic}
+
+Research notes:
+{research_notes}
+
+Instructions:
+- Create a detailed, structured outline with main sections and subsections
+- Include introduction, literature review, methodology, results, discussion, and conclusion
+- Use clear hierarchical structure with numbers and letters
+- Make sure response should be generated in 1500 characters including spaces.
+
+Research paper outline:
+"""
+
+# Prompt template for outline revision based on feedback
+OUTLINE_REVISION_PROMPT = """
+You are an expert academic writer. Given a current outline, feedback for revision, and research notes, revise the outline accordingly.
+
+Current outline:
+{current_outline}
+
+Feedback for revision:
+{feedback}
+
+Research notes:
+{research_notes}
+
+Instructions:
+- Revise the outline based on the provided feedback
+- Maintain the academic structure and flow
+- Ensure all sections are properly organized
+- Make sure response should be generated in 1500 characters including spaces.
+
+Revised research paper outline:
+"""
+
+def get_outline_builder_chain():
+    """
+    Returns a LangChain LLMChain for initial outline building.
+    """
+    prompt = PromptTemplate(
+        input_variables=["refined_topic", "research_notes"],
+        template=OUTLINE_BUILDER_PROMPT
+    )
+    
+    # Always enable streaming in the LLM - callbacks will be passed during execution
+    llm = OpenAI(
+        temperature=0.2, 
+        openai_api_key=get_openai_api_key(),
+        streaming=True  # Always enable streaming
+    )
+    
+    return LLMChain(llm=llm, prompt=prompt, output_key="outline")
+
+def get_outline_revision_chain():
+    """
+    Returns a LangChain LLMChain for outline revision based on feedback.
+    """
+    prompt = PromptTemplate(
+        input_variables=["current_outline", "feedback", "research_notes"],
+        template=OUTLINE_REVISION_PROMPT
+    )
+    
+    # Always enable streaming in the LLM - callbacks will be passed during execution
+    llm = OpenAI(
+        temperature=0.7, 
+        openai_api_key=get_openai_api_key(),
+        streaming=True  # Always enable streaming
+    )
+    
+    return LLMChain(llm=llm, prompt=prompt, output_key="outline")
+
+def outline_builder_node(state: dict) -> dict:
+    """
+    Wrapper node for initial outline building.
+    """
+    # Create the chain
+    chain = get_outline_builder_chain()
+    
+    # Call the chain with required inputs
+    result = chain({
+        "refined_topic": state["refined_topic"],
+        "research_notes": state["research_notes"]
+    })
+    
+    # Update state with the result
+    state.update(result)
+    return state
+
+def outline_revision_node(state: dict) -> dict:
+    """
+    Wrapper node for outline revision based on feedback.
+    """
+    # Get feedback, default to empty string if missing
+    feedback = state.get("feedback", "")
+    
+
+    
+    # Create the revision chain
+    chain = get_outline_revision_chain()
+    
+    # Call the chain with only the required inputs (matching the prompt template)
+    result = chain({
+        "current_outline": state["outline"],
+        "feedback": feedback,
+        "research_notes": state["research_notes"]
+    })
+    
+    # Update state with the revised outline
+    state.update(result)
+    return state
+
+

agents/research_retriever.py

@@ -0,0 +1,163 @@
+"""
+LangChain LLMChain for retrieving research notes based on a refined topic with yield support.
+"""
+from typing import Any, Dict, Generator
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import OpenAI
+
+from config import get_openai_api_key
+from streaming_config import get_chunk_size, is_yield_enabled
+
+# Prompt template for research retrieval
+RESEARCH_RETRIEVER_PROMPT = """
+You are an expert research assistant. Given a refined research topic, retrieve or summarize the most relevant and recent academic research, findings, and key points. Present the information as concise bullet points.
+
+Refined topic: {refined_topic}
+
+Instructions:
+- Provide comprehensive but concise research notes
+- Use clear bullet points for easy reading
+- Focus on the most important findings and key points
+- Make sure response should be generated in 2000 characters including spaces.
+
+Research notes (bullet points):
+"""
+
+def get_research_retriever_chain():
+    """
+    Returns a LangChain LLMChain for research retrieval.
+    """
+    prompt = PromptTemplate(
+        input_variables=["refined_topic"],
+        template=RESEARCH_RETRIEVER_PROMPT
+    )
+    
+    # Always enable streaming in the LLM - callbacks will be passed during execution
+    llm = OpenAI(
+        temperature=0.1, 
+        openai_api_key=get_openai_api_key(),
+        streaming=True  # Always enable streaming
+    )
+    
+    return LLMChain(llm=llm, prompt=prompt, output_key="research_notes")
+
+def yield_research_retrieval(refined_topic: str, preset: str = None) -> Generator[str, None, None]:
+    """
+    Yield research retrieval results progressively
+    
+    Args:
+        refined_topic: The refined research topic
+        preset: Optional streaming preset
+        
+    Yields:
+        str: Progressive research notes
+    """
+    if not is_yield_enabled(preset):
+        # Fallback to non-yield processing
+        chain = get_research_retriever_chain()
+        result = chain.run(refined_topic=refined_topic)
+        yield result
+        return
+    
+    try:
+        # Import required modules
+        from langchain.prompts import PromptTemplate
+        from langchain_openai import ChatOpenAI
+
+        from config import get_openai_api_key
+
+        # Create prompt template
+        prompt = PromptTemplate(
+            input_variables=["refined_topic"],
+            template=RESEARCH_RETRIEVER_PROMPT
+        )
+        
+        # Create LLM with streaming
+        llm = ChatOpenAI(
+            temperature=0.1, 
+            openai_api_key=get_openai_api_key(),
+            streaming=True
+        )
+        
+        # Format the prompt
+        formatted_prompt = prompt.format(refined_topic=refined_topic)
+        
+        # Get chunk size for this step
+        chunk_size = get_chunk_size("research_retriever", preset)
+        
+        # Call LLM and yield results progressively
+        result = llm.invoke(formatted_prompt)
+        content = result.content
+        
+        # Yield content in chunks
+        for i in range(0, len(content), chunk_size):
+            chunk = content[i:i + chunk_size]
+            yield chunk
+            
+    except Exception as e:
+        yield f"Error in research retrieval: {str(e)}"
+
+def yield_research_by_sections(refined_topic: str, sections: list = None) -> Generator[str, None, None]:
+    """
+    Yield research retrieval organized by sections
+    
+    Args:
+        refined_topic: The refined research topic
+        sections: List of research sections to focus on
+        
+    Yields:
+        str: Progressive research notes by section
+    """
+    if not sections:
+        sections = ["Background", "Key Findings", "Methodology", "Conclusions"]
+    
+    yield f"Retrieving research for: {refined_topic}"
+    
+    for section in sections:
+        yield f"\n--- {section} ---"
+        
+        # Create section-specific prompt
+        section_prompt = f"""
+        Focus on the {section.lower()} aspects of research related to: {refined_topic}
+        
+        Provide key points and findings for the {section} section.
+        """
+        
+        # Process section with yield
+        for chunk in yield_research_retrieval(section_prompt):
+            yield chunk
+        
+        yield "\n"
+
+def process_research_with_filters(refined_topic: str, filters: dict = None) -> Generator[str, None, None]:
+    """
+    Process research retrieval with optional filters using yield generators
+    
+    Args:
+        refined_topic: The refined research topic
+        filters: Optional filters for research focus
+        
+    Yields:
+        str: Progressive filtered research results
+    """
+    if filters:
+        yield f"Applying research filters: {list(filters.keys())}"
+        
+        # Apply filters to the prompt
+        filter_text = ", ".join([f"{k}: {v}" for k, v in filters.items()])
+        enhanced_prompt = f"""
+        Refined topic: {refined_topic}
+        Research filters: {filter_text}
+        
+        Please focus the research retrieval on these specific aspects.
+        """
+    else:
+        enhanced_prompt = f"Refined topic: {refined_topic}"
+    
+    # Yield the enhanced research retrieval
+    for chunk in yield_research_retrieval(enhanced_prompt):
+        yield chunk
+

agents/topic_analyzer.py

@@ -0,0 +1,125 @@
+"""
+LangChain LLMChain for analyzing and refining a research topic with yield support.
+"""
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import OpenAI
+from langchain.callbacks.base import BaseCallbackHandler
+from config import get_openai_api_key
+from typing import Dict, Any, Generator
+from streaming_config import get_chunk_size, is_yield_enabled
+
+# Prompt template for topic analysis
+TOPIC_ANALYZER_PROMPT = """
+You are an expert research assistant. Given a user-provided research topic, refine it for clarity, focus, and academic rigor. 
+
+Original topic: {topic}
+
+Instructions:
+- Refine the topic into a clear, focused research question
+- Keep the response concise and academic
+- Make sure response should be generated in 500 characters including spaces.
+
+Refined topic (one sentence):
+"""
+
+def get_topic_analyzer_chain():
+    """
+    Returns a LangChain LLMChain for topic analysis.
+    """
+    prompt = PromptTemplate(
+        input_variables=["topic"],
+        template=TOPIC_ANALYZER_PROMPT
+    )
+    
+    # Always enable streaming in the LLM - callbacks will be passed during execution
+    llm = OpenAI(
+        temperature=0.3, 
+        openai_api_key=get_openai_api_key(),
+        streaming=True  # Always enable streaming
+    )
+    
+    return LLMChain(llm=llm, prompt=prompt, output_key="refined_topic")
+
+def yield_topic_analysis(topic: str, preset: str = None) -> Generator[str, None, None]:
+    """
+    Yield topic analysis results progressively
+    
+    Args:
+        topic: The research topic to analyze
+        preset: Optional streaming preset
+        
+    Yields:
+        str: Progressive analysis results
+    """
+    if not is_yield_enabled(preset):
+        # Fallback to non-yield processing
+        chain = get_topic_analyzer_chain()
+        result = chain.run(topic=topic)
+        yield result
+        return
+    
+    try:
+        # Import required modules
+        from langchain_openai import ChatOpenAI
+        from langchain.prompts import PromptTemplate
+        from config import get_openai_api_key
+        
+        # Create prompt template
+        prompt = PromptTemplate(
+            input_variables=["topic"],
+            template=TOPIC_ANALYZER_PROMPT
+        )
+        
+        # Create LLM with streaming
+        llm = ChatOpenAI(
+            temperature=0.3, 
+            openai_api_key=get_openai_api_key(),
+            streaming=True
+        )
+        
+        # Format the prompt
+        formatted_prompt = prompt.format(topic=topic)
+        
+        # Get chunk size for this step
+        chunk_size = get_chunk_size("topic_analyzer", preset)
+        
+        # Call LLM and yield results progressively
+        result = llm.invoke(formatted_prompt)
+        content = result.content
+        
+        # Yield content in chunks
+        for i in range(0, len(content), chunk_size):
+            chunk = content[i:i + chunk_size]
+            yield chunk
+            
+    except Exception as e:
+        yield f"Error in topic analysis: {str(e)}"
+
+def process_topic_with_feedback(topic: str, feedback: str = None) -> Generator[str, None, None]:
+    """
+    Process topic analysis with optional feedback using yield generators
+    
+    Args:
+        topic: The research topic
+        feedback: Optional feedback for refinement
+        
+    Yields:
+        str: Progressive processing results
+    """
+    if feedback:
+        # Include feedback in processing
+        enhanced_prompt = f"""
+        Original topic: {topic}
+        Feedback: {feedback}
+        
+        Please refine the topic considering the feedback provided.
+        """
+        yield "Processing topic with feedback..."
+    else:
+        enhanced_prompt = f"Original topic: {topic}"
+        yield "Processing topic analysis..."
+    
+    # Yield the enhanced prompt for processing
+    for chunk in yield_topic_analysis(enhanced_prompt):
+        yield chunk