Upload folder using huggingface_hub

.github/workflows/lint_pytest.yml

@@ -0,0 +1,25 @@
+name: lint_pytest
+on: push
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: psf/black@stable
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.9.19"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+    - name: Ruff
+      run: |
+        ruff check --output-format=github .
+    - name: Mypy
+      run: |
+        mypy . --install-types --non-interactive
+    - name: Test with pytest
+      run: |
+        pytest -s tests.py --doctest-modules --junitxml=junit/test-results.xml --cov=com --cov-report=xml --cov-report=html

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,13 @@
+**cache**
+**playground**
+.DS_Store
+.env
+settings.json
+data
+logs
+keys.yaml
+*.egg-info
+research_trails
+KEYS.py
+.gradio/
+**.pdf

KEYS_TEMPLATE.py

@@ -0,0 +1,3 @@
+ANTHROPIC = "sk-xxx"
+FIREWORKS_AI = "xxx"
+OPENAI = "sk-proj-xxx"

README.md

@@ -1,12 +1,68 @@
 ---
-title: Research Assistant
-emoji: 🚀
-colorFrom: indigo
-colorTo: yellow
+title: research-assistant
+app_file: src/research_assistant/web/app.py
 sdk: gradio
 sdk_version: 5.6.0
-app_file: app.py
-pinned: false
 ---
+# Research Assistant
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This is a Research Assistant that helps in analyzing and simplifying the content present in a research article, such that you don't have to read the whole thing to understand what knowledge is being presented inside the article. This tool takes care of it and provides you the understanding you would need.
+
+# How to run?
+## Step 1:
+First install the requirements
+```bash
+pip install -r requirements.txt
+pip install -e .
+```
+
+## Step 2:
+create a file named keys.yaml following the template present in keys_template.yaml
+Input your api keys inside keys.yaml and save them
+
+## Step 3:
+Update the contents in config/config.yaml file. The path for your file name, and the search parameters for articles are present inside the config.yaml file. Before every run, if you want to change the serach configuration or summarization parameters, you need to update the config.yaml file.
+
+## Step 4:
+The Summarization pipeline can be run in 2 ways:
+
+### From Command Line Interface as Pip Package:
+Step 1 installs the whole repo as a pip installable package in editable mode in your pip. 
+To access the package and get the summary of the file, run the following command:
+
+
+```bash
+research --pipeline_name
+```
+### From running the Main File:
+
+##### Confirm the Arguments:
+To change the model names, filepath to get the summary, filepath to save the summary, make changes in the config/config.yaml file.
+
+##### Run the following command
+```bash
+python src/research_assistant/main.py --pipeline_name
+```
+
+# Different Pipelines:
+There are two pipelies available here:
+## Summarization Pipeline:
+Given a paper, this pipeline gives out the summarization. The paper filepath can be set in config/config.yaml. To activate this pipeline, run the following command:
+
+```bash
+# If you want to use the package version, run the following command
+research --summarize_article
+
+#If you directly want to directly compile in CLI, run the following command
+python src/research_assistant/main.py --summarize_article
+```
+## Searching for Articles:
+Given a few keywords, and other parameters, this pipeline will crawl Arxiv and get you the artciles that are relevant for you. To activate this pipeline, run the following command
+
+```bash
+# If you want to use the package version, run the following command
+research --search_articles
+
+#If you directly want to directly compile in CLI, run the following command
+python src/research_assistant/main.py --search_articles
+```

config/config.yaml

@@ -0,0 +1,32 @@
+# RENAME THIS TO YOUR CONFIGURATIONS
+article_details:
+  file_path: 'data/2106.07691v1.pdf'
+  summary_save_dir: 'data/summary_results'
+
+# TODO: Remove this when TECH-67 is implemented
+article_search_details:
+  search_terms: ['Hallucination', 'Natural Language Inference']
+  num_results: 5
+  date_range:
+    start_date: '2023-01-01'
+    end_date: '2024-12-31'
+  sort_by: 'submittedDate'
+  sort_order: 'descending'
+
+#################################################################################################################
+#              MAKE CHANGES FROM HERE ONLY IF YOU ARE SURE OF WHAT YOU ARE DOING, ELSE DO NOT EDIT
+#################################################################################################################
+
+planner:
+  model_name: 'claude-3-5-sonnet-20241022'
+
+planner_parser:
+  tool_list_model: 'claude-3-5-sonnet-20241022'
+  argument_list_model: 'claude-3-5-sonnet-20241022'
+  dependency_list_model: 'claude-3-5-sonnet-20241022'
+
+qa_tool:
+  model_name: 'claude-3-5-sonnet-20241022'
+
+solver:
+  model_name: 'claude-3-5-sonnet-20241022'

mypy.ini

@@ -0,0 +1,2 @@
+[mypy]
+ignore_missing_imports = True

requirements.txt

@@ -0,0 +1,28 @@
+python-dotenv
+langsmith
+langgraph
+langchain
+numexpr
+langchain-anthropic
+langchain-community
+langchain-core
+pdfminer
+pytest
+pdfminer.six
+arxiv
+python-box
+langchain-fireworks
+langchain-google_vertexai
+langchain-openai
+types-PyYAML
+gradio
+markdown2
+fpdf2
+mistletoe
+pydantic==2.9.0
+xmltodict
+mypy
+types-requests
+ruff
+pytest
+pytest-cov

setup.py

@@ -0,0 +1,30 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+__version__ = "0.0.0"
+REPO_NAME = "research-assistant"
+AUTHOR_USER_NAME = "Actualization-AI"
+SRC_REPO = "research-assistant"
+AUTHOR_EMAIL = "manas@actualization.ai"
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_USER_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="A Research Assistant which can scrape and summarize research articles for easier understanding",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url=f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}/issues",
+    },
+    entry_points={  # Entry point for CLI
+        "console_scripts": [
+            "research=research_assistant.main:main",  # Command to run main function
+        ]
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+)

src/research_assistant/app_logging/__init__.py

@@ -0,0 +1,14 @@
+import logging
+import os
+import sys
+
+log_dir = "logs"
+log_filepath = os.path.join(log_dir, "running_logs.log")
+os.makedirs(log_dir, exist_ok=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s: %(levelname)s: %(module)s: %(message)s]",
+    handlers=[logging.FileHandler(log_filepath), logging.StreamHandler(sys.stdout)],
+)
+app_logger = logging.getLogger("ResearchAssistantLogger")

src/research_assistant/components/agent.py

@@ -0,0 +1,74 @@
+import os
+import sys
+
+from langchain_anthropic import ChatAnthropic
+from langchain_fireworks import ChatFireworks
+from langchain_google_vertexai import ChatVertexAI
+from langchain_openai import ChatOpenAI
+
+sys.path.append(os.getcwd())
+import KEYS
+from research_assistant.app_logging import app_logger
+
+
+def set_api_key(env_var: str, api_key: str):
+    os.environ[env_var] = api_key
+
+
+class Agent:
+    def __init__(self, model_name: str):
+        model_classes = {
+            "gpt": (
+                (ChatOpenAI, "OPENAI_API_KEY", KEYS.OPENAI)  # type: ignore
+                if "OPENAI" in KEYS.__dict__
+                else (None, None, None)
+            ),
+            "claude": (
+                (ChatAnthropic, "ANTHROPIC_API_KEY", KEYS.ANTHROPIC)  # type: ignore
+                if "ANTHROPIC" in KEYS.__dict__
+                else (None, None, None)
+            ),
+            "gemini": (
+                (ChatVertexAI, "GOOGLE_API_KEY", KEYS.VERTEX_AI)  # type: ignore
+                if "VERTEX_AI" in KEYS.__dict__
+                else (None, None, None)
+            ),
+            "fireworks": (
+                (ChatFireworks, "FIREWORKS_API_KEY", KEYS.FIREWORKS_AI)  # type: ignore
+                if "FIREWORKS_AI" in KEYS.__dict__
+                else (None, None, None)
+            ),
+        }
+        max_tokens_map = {
+            "gpt-3.5": 16000,
+            "gpt-4": 8000,
+            "gpt-4o-mini": 8000,
+            "llama-v3p2-1b-instruct": 128000,
+            "llama-v3p2-3b-instruct": 128000,
+            "llama-v3p1-8b-instruct": 128000,
+            "llama-v3p1-70b-instruct": 128000,
+            "llama-v3p1-405b-instruct": 128000,
+            "mixtral-8x22b-instruct": 64000,
+            "mixtral-8x7b-instruct": 32000,
+            "mixtral-8x7b-instruct-hf": 32000,
+            "qwen2p5-72b-instruct": 32000,
+            "gemma2-9b-it": 8000,
+            "llama-v3-8b-instruct": 8000,
+            "llama-v3-70b-instruct": 8000,
+            "llama-v3-70b-instruct-hf": 8000,
+        }
+        for key, (model_class, env_var, api_key) in model_classes.items():
+            if model_class is not None and key in model_name:
+                set_api_key(env_var, api_key)  # type: ignore
+                model = model_class(model=model_name, temperature=0.5)  # type: ignore
+                max_tokens = max_tokens_map.get(model_name, 128000)
+                break
+        else:
+            raise ValueError(f"Model {model_name} not supported")
+
+        app_logger.info(f"Model {model_name} is initialized successfully")
+        self.model = model
+        self.max_tokens = max_tokens
+
+    def get_model(self):
+        return self.model

src/research_assistant/components/agent_tools.py

@@ -0,0 +1,96 @@
+from typing import List, Optional
+
+from langchain_anthropic.chat_models import ChatAnthropic
+from langchain_community.utilities.arxiv import ArxivAPIWrapper
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+
+class ExecuteCode(BaseModel):
+    """The input to the summarizer tool function."""
+
+    reasoning: str = Field(
+        description="The reasoning behind the code expression, including how context is included, if applicable.",
+    )
+    answer: str = Field(
+        ...,
+        description="The answer to the question about the research article.",
+    )
+
+
+def get_qa_tool(llm: ChatAnthropic):
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            SystemMessage(
+                (
+                    "You are an advanced research assistant answering questions about a specific research article. The question may require external information beyond the research article itself. This external information, along with the parsed content from the research article, will be provided as 'Additional Context'.\n\n"
+                    # comment for readibility
+                    "You must:\n"
+                    "1. Thoroughly analyze the research article to understand its key objectives, methods, findings, and implications.\n"
+                    "2. Use the research article and any additional context to construct a comprehensive, well-informed answer to the given question.\n"
+                    "3. Explicitly reference and combine information from both the research article and the additional context when needed, ensuring that the response is relevant, accurate, and complete.\n\n"
+                    # comment for readibility
+                    "Follow these steps when answering:\n"
+                    "- If the question can be answered using information from the research article alone, do so.\n"
+                    "- If additional context is needed to supplement or clarify the answer, carefully integrate it with the information from the article.\n"
+                    "- Ensure the response is precise, concise, and clear, citing the research article and additional context appropriately."
+                )
+            ),
+            MessagesPlaceholder(variable_name="context", optional=True),
+            MessagesPlaceholder(variable_name="question"),
+        ]
+    )
+    summarizer = prompt | llm.with_structured_output(ExecuteCode)
+
+    def get_answer(
+        question: str,
+        context: Optional[List[str]] = None,
+        config: Optional[RunnableConfig] = None,
+    ):
+        context_str = "\n".join(context).strip() if context else None
+        chain_input = {
+            "question": [HumanMessage(question)],
+            "context": [
+                (
+                    HumanMessage(
+                        (
+                            f"Additional context has been provided from other tools (such as parsed PDF content or information retrieved from internet searches). Use it to substitute into any {{#}} variables or other words in the question. Do not directly substitute the value. Rather, extract information in the best suitable format and then substitute. Use this context to enrich your answer by integrating it with the information from the research article. Context:\n{context_str}\n\n"
+                            # comment for readibility
+                            "Instructions:\n"
+                            "- Identify where the additional context is necessary to supplement or clarify the research article's information.\n"
+                            "- Replace any placeholders or variable information (e.g., {{#}}) with appropriate details from the context.\n"
+                            "- Make sure the final answer blends the research article content with the additional context in a cohesive and accurate manner.\n\n"
+                            # comment for readibility
+                            "Once done, output the updated, comprehensive answer."
+                        )
+                    )
+                    if context_str
+                    else HumanMessage("No Additional Context is Provided")
+                )
+            ],
+        }
+        return summarizer.invoke(chain_input, config)
+
+    return StructuredTool.from_function(
+        name="qa_agent",
+        func=get_answer,
+        description="This tool is designed to answer specific questions about a research article, rather than simply providing a full summary. It offers a well-rounded and accurate response to your inquiry, allowing you to focus on the exact information you need without having to go through the entire article.",
+    )
+
+
+def get_arxiv_tool(
+    k_results: int = 3,
+    max_query_length: int = 300,
+    max_docs: int = 3,
+    doc_content_chars_max: int = 40000,
+):
+    return ArxivAPIWrapper(  # type: ignore
+        top_k_results=k_results,
+        ARXIV_MAX_QUERY_LENGTH=max_query_length,
+        load_max_docs=max_docs,
+        load_all_available_meta=False,
+        doc_content_chars_max=doc_content_chars_max,
+    )

src/research_assistant/components/arxiv_search_api.py

@@ -0,0 +1,84 @@
+from datetime import datetime
+
+import requests
+import xmltodict
+
+from research_assistant.app_logging import app_logger
+from research_assistant.constants import ARXIV_API_ACCESS_POINT
+from research_assistant.entity import ArticleSearchConfig
+
+
+class ArxivApiWrap:
+    def __init__(self, config: ArticleSearchConfig):
+        self.config = config
+
+    def convert_link_to_pdflink(self, link):
+        return link.replace("/abs/", "/pdf/") + ".pdf"
+
+    def convert_date(self, date):
+        return datetime.strptime(date, "%Y-%m-%d").strftime("%Y%m%d")
+
+    """
+    Fetches the response from the arXiv API based on the specified search terms and parameters.
+    Args used by the arXiv API:
+       Keywords (list of str): Contains the search terms
+       max_length (int): Maximum number of articles to retrieve
+       Date range : Contains start and end dates for the search
+       Sort by : Sorts the results by a specific field (e.g., submittedDate)
+       Sort order (str): Sort order for the results (e.g., asc, desc)
+
+    Returns:
+        requests.Response: The HTTP response object returned by the arXiv API.
+    """
+
+    def get_arxiv_api_response(self):
+        keyword_query = " AND all:".join([f"'{kw}'" for kw in self.config.search_terms])
+        if self.config.date_range.start_date:
+            query = f" all:{keyword_query}  AND submittedDate:[{self.convert_date(self.config.date_range.start_date)} TO {self.convert_date(self.config.date_range.end_date)}]"
+        else:
+            query = f" all:{keyword_query}"
+        params = {
+            "search_query": query,
+            "start": 0,  # Starts from page 1 of the results obtained
+            "max_results": self.config.num_results,  # Adjust the number of results as needed
+            "sortBy": self.config.sort_by,  # Sort by submission date
+            "sortOrder": self.config.sort_order,  # Sort in descending order (latest first)
+        }
+        return requests.get(ARXIV_API_ACCESS_POINT, params=params)
+
+    """
+    Retrieves article search results from the arXiv API and logs detailed information about each article.
+
+    This method fetches the API response, parses the XML content into a structured format,
+    and extracts key information such as the title, summary, link, and authors for each article.
+
+    Returns:
+    list of str: A list of article links retrieved from the arXiv API.
+    """
+
+    def get_article_search_result(self):
+        response = self.get_arxiv_api_response()  # Fetch the API response
+        article_links = []
+        if response.status_code == 200:  # Check if the request was successful
+            # Parse the response (arXiv API returns XML)
+            data = xmltodict.parse(response.content)
+            for entry in data["feed"]["entry"]:
+                title, summary, link, authors = (
+                    entry["title"],
+                    entry["summary"],
+                    entry["id"],
+                    [author["name"] for author in entry["author"]],
+                )
+                app_logger.info(
+                    f"Title: {title}\n Authors: {authors} \n,Abstract: {summary}\n Page Link: {link}\n PDF Link: {self.convert_link_to_pdflink(link)}\n Paper Id: {link.split('/')[-1]}\n {'-'*80}"
+                )
+                article_links.append(link)
+        else:
+            app_logger.info(f"Failed to retrieve papers: {response.status_code}")
+        return article_links
+
+    def download_pdf(self, pdf_url):
+        response, title = requests.get(pdf_url), pdf_url.split("/")[0]
+        with open(f"data/{title}.pdf", "wb") as f:
+            f.write(response.content)
+            print(f"Downloaded: {title}.pdf")

src/research_assistant/components/pdfParser.py

@@ -0,0 +1,68 @@
+import re
+
+from pdfminer.high_level import extract_pages
+from pdfminer.layout import LTTextContainer
+
+from research_assistant.app_logging import app_logger
+
+
+def pdf_parser(pdf_path):
+    """
+    Extracts text from a PDF file, removing headers, footers, and page numbers.
+    Args:
+        pdf_path (str): The file path to the PDF.
+    Returns:
+        str: The extracted text suitable for LLM input.
+    """
+    extracted_text = []
+    header_counter, footer_counter = {}, {}
+    header_patterns, footer_patterns = set(), set()
+    # Matches lines with page numbers
+    page_number_pattern = re.compile(r"^(Page\s+)?\d+(/\d+)?$")
+
+    try:
+        # First pass: identify headers and footers by tracking recurring lines
+        total_pages = 0
+        for page_layout in extract_pages(pdf_path):
+            total_pages += 1
+            page_text = [
+                element.get_text().strip()
+                for element in page_layout
+                if isinstance(element, LTTextContainer) and element.get_text().strip()
+            ]
+
+            if len(page_text) >= 2:
+                header, footer = page_text[0], page_text[-1]
+                header_counter[header] = header_counter.get(header, 0) + 1
+                footer_counter[footer] = footer_counter.get(footer, 0) + 1
+
+        # Determine most common headers and footers
+        header_patterns = {
+            k for k, v in header_counter.items() if v > total_pages * 0.5
+        }
+        footer_patterns = {
+            k for k, v in footer_counter.items() if v > total_pages * 0.5
+        }
+
+        # Compile regex patterns
+        header_regexes = [re.compile(re.escape(header)) for header in header_patterns]
+        footer_regexes = [re.compile(re.escape(footer)) for footer in footer_patterns]
+
+        # Second pass: extract and clean text
+        for page_layout in extract_pages(pdf_path):
+            page_text = [
+                element.get_text().strip()
+                for element in page_layout
+                if isinstance(element, LTTextContainer) and element.get_text().strip()
+            ]
+            extracted_text.extend(
+                line
+                for line in page_text
+                if not any(regex.match(line) for regex in header_regexes)
+                and not any(regex.match(line) for regex in footer_regexes)
+                and not page_number_pattern.match(line)
+            )
+        return " ".join(extracted_text).replace("\n", " ").strip()
+    except Exception as e:
+        app_logger.error(f"Failed to parse PDF {pdf_path}: {e}")
+        return ""

src/research_assistant/components/planner.py

@@ -0,0 +1,112 @@
+from typing import Dict, List, Optional
+
+from langchain_anthropic.chat_models import ChatAnthropic
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from research_assistant.components.plannerParser import PlannerParser
+from research_assistant.constants import HEILMEIER_CATECHISM
+
+
+class PlannerOutput(BaseModel):
+    plan_str: str = Field(
+        ...,
+        description=(
+            "This plan includes a detailed breakdown of each step, specifying the task, the tool used, the arguments provided, and any dependencies (outputs from previous steps) required as inputs for that step. An example of a single step would be:\n"
+            'Plan_step: "Using the different shots from #E2, analyze their impact on the game. #E3: LLM [What impact do the shots mentioned in #E2 have on the game?]"'
+        ),
+    )
+    tools: list[str] = Field(
+        ..., description="The Tool each step of the plan needs to use."
+    )
+    dependencies: Dict[int, list[int]] = Field(
+        ...,
+        description=(
+            "A dictionary of dependencies, which elaborates on what outputs are needed for each step in the plan to execute. So that the output of those steps is retrieved and added inside the prompt for the present step. An example of a dependency would be: {2 : [1]}"
+        ),
+    )
+    arguments: list[str] = Field(
+        ...,
+        description="The arguments that the tool needs to be given. These arguments will be used in the prompt to get the output.",
+    )
+
+
+def get_planner(llm: ChatAnthropic):
+    prompt_template = ChatPromptTemplate.from_messages(
+        [
+            SystemMessage(
+                (
+                    f"You are a research assistant whose primary job is to explain a research article in a clear and accessible way. Your goal is to read the entire article and provide an explanation that allows other researchers to understand its content without having to read it themselves. Additionally, you should be able to answer any questions they might have. The most efficient way to accomplish this is by answering the following Heilmeier catechism questions in detail:\n{HEILMEIER_CATECHISM}\n\n"
+                    # comment for readability
+                    "You are a planner of the research assistant agent architecture. You need to generate a step-by-step plan process such that you can get all the answers to the given questions using the provided tools:\n"
+                    "(1) Arxiv [input]: A tool that searches for results from the Arxiv website. It is useful for finding information on specific topics. The input should be a concise text string, similar to a search query used in a Google search. This tool searches published articles and provides details about the article and a summary of its content. The information obtained is reliable, so if you need information not covered in the research article or require external information, use this tool.\n"
+                    "(2) LLM [input]: A pretrained language model that can answer any questions. You provide the query and additional context, and it generates a relevant, summarized answer. The additional context may include the output from previous steps or evidence gathered using the Arxiv tool.\n\n"
+                    # comment for readability
+                    "For example,\n"
+                    "Task: Explain different kinds of cricket shots.\n"
+                    "plan_str:\n"
+                    '1. Start by finding different kinds of cricket shots. #E1 = Arxiv["Different kinds of cricket shots"].\n'
+                    '2. Given the result of the search query, find different types of cricket shots. #E2 = LLM ["Find the different types of cricket shots given the result of search query #E1."]\n'
+                    '3. Now, let us find out about different types of cricket shots and their impact on the game. #E3 = LLM ["Given the different types of cricket shots from the step #E1 till step #E2, how does their impact on the game look like?"]\n\n'
+                    # comment for readability
+                    "Describe the steps of your plan with rich details. Each step of the plan should contain #E as shown in the example. DO NOT write a step at the end to summarize the plan."
+                )
+            ),
+            MessagesPlaceholder(variable_name="context", optional=True),
+            MessagesPlaceholder(variable_name="article_text"),
+        ]
+    )
+    planner = prompt_template | llm
+
+    # parse the response to get the plan, tasks, tools, dependencies, and arguments
+    def parse_plan(plan_string: str):
+        parser = PlannerParser(plan_string=plan_string)
+        return PlannerOutput(
+            plan_str=plan_string,
+            tools=parser.get_tool_list(),
+            dependencies=parser.get_dependency_list(),
+            arguments=parser.get_argument_list(),
+        )
+
+    def get_plan(
+        article_text: str,
+        _context: Optional[List[str]] = None,  # TODO: rename when context is used
+        _config: Optional[RunnableConfig] = None,  # TODO: rename when config is used
+    ):
+        response = planner.invoke(
+            {
+                "article_text": [
+                    HumanMessage(
+                        f"You are given a research document with the following content:\n{article_text}.\n\n"
+                        "Read the research document thoroughly. Using the tools provided to you, generate a step-by-step plan that would use these tools in the specified step-wise manner to get a detailed summary for all the questions."
+                    )
+                ]
+            }
+        )
+        if isinstance(response.content, str):
+            return parse_plan(response.content)
+        else:
+            raise TypeError(
+                "Response.Content i.e the plan given out from the llm must be a string"
+            )
+
+    return StructuredTool.from_function(
+        name="planner",
+        func=get_plan,
+        description=(
+            (
+                'This tool is used to generate a plan for obtaining a summary of research articles. Rather than providing the entire summary, it focuses on creating a step-by-step plan that guides the agent in producing a detailed, accurate summary of a research article. This tool can be considered the "brain" that designs the agent\'s workflow.\n'
+                "For Example:\n"
+                "Input: The parsed pdf string of the article\n"
+                "Answer: An object consisting of the following fields:\n"
+                "plan_string: str\n"
+                "steps : List[str]\n"
+                "tools : List[str]\n"
+                "dependencies : dict\n"
+                "arguments : List[str]\n"
+            )
+        ),
+    )

src/research_assistant/components/plannerParser.py

@@ -0,0 +1,168 @@
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+from research_assistant.components.agent import Agent
+from research_assistant.config.configuration import ConfigurationManager
+
+
+class PlannerParser:
+    tool_list_schema = {
+        "title": "ToolSchema",
+        "description": "This is the schema used to get tools list, after parsing the plan string, which will be used to do tool or fucntion calling for the further parts of the agentic framework",
+        "type": "object",
+        "properties": {
+            "tools": {
+                "type": "array",
+                "items": {"type": "string"},
+                "title": "Tools",
+                "description": "The Tool each step in the plan needs to access. If we have seven steps, this has a list of 7 values depicting the tool name for each step that needs to be used",
+                "default": [],
+            },
+        },
+        "required": ["tools"],
+    }
+    argument_list_schema = {
+        "title": "ArgumentSchema",
+        "description": "This is the schema used to get argument list used for each tool call, after parsing the plan string, which will be used to do tool or fucntion calling for the further parts of the agentic framework",
+        "type": "object",
+        "properties": {
+            "arguments": {
+                "type": "array",
+                "items": {"type": "string"},
+                "title": "Arguments",
+                "description": "The Arugment for tool call for each step in the plan needs to access. If we have seven steps, this has a list of 7 values depicting the argument value for each step that needs to be used",
+                "default": [],
+            },
+        },
+        "required": ["arguments"],
+    }
+    dependency_list_schema = {
+        "title": "DependentSchema",
+        "description": "This schema defines dependencies for each tool call to fetch additional context after parsing the plan string for the agentic framework.",
+        "type": "object",
+        "properties": {
+            "dependencies": {
+                "type": "object",
+                "additionalProperties": {
+                    "type": "array",
+                    "items": {"type": "integer"},
+                },
+                "title": "Dependencies",
+                "description": "A dictionary where each key is a step identifier, and the value is an array of integers, representing the step dependencies.",
+                "default": {},
+            }
+        },
+        "required": ["dependencies"],
+    }
+
+    def __init__(self, plan_string: str):
+        self.plan_string = plan_string
+        self.config = ConfigurationManager().get_planner_parser_config()
+
+    def get_tool_list(self):
+        llm = Agent(self.config.tool_list_model).get_model()
+        prompt_template = ChatPromptTemplate.from_messages(
+            [
+                SystemMessage(
+                    (
+                        "You are a planner parser. You will be given a plan consisting of a series of steps, and you need to give me a list consisting of what tool is being used for each step.\n"
+                        "So if there are 7 steps, I need a list of length 7, where each value is the tool that is being used for the corresponding step.\n"
+                        "For example:\n"
+                        '1. Find out the temperature right now. #E1 = Google["What is the temperature near me?"]\n'
+                        '2. Check the weather forecast for tomorrow. #E2: WeatherAPI["What will be the weather like tomorrow?"]\n'
+                        '3. Get the top 5 news articles related to the topic of climate change. !3 = NewsAPI["What are the top 5 news articles about climate change?"]\n'
+                        "If this is the given plan, the output should be: ['Google', 'WeatherAPI', 'NewsAPI'].\n"
+                        "Be very careful that you don't miss any step or tool. The number of steps and tools should be the same. Check your output thoroughly. Write only one tool on each line."
+                    ),
+                ),
+                MessagesPlaceholder(variable_name="plan"),
+                MessagesPlaceholder(variable_name="context", optional=True),
+            ]
+        )
+        tool_parser = prompt_template | llm.with_structured_output(
+            self.tool_list_schema
+        )
+        return tool_parser.invoke(
+            {
+                "plan": [
+                    HumanMessage(
+                        f"This is the generated plan:\n{self.plan_string}\n\n"
+                        "Now parse this content and give me the list of tools for each step."
+                    )
+                ]
+            }
+        )["tools"]
+
+    def get_argument_list(self):
+        llm = Agent(self.config.argument_list_model).get_model()
+        prompt_template = ChatPromptTemplate.from_messages(
+            [
+                SystemMessage(
+                    (
+                        "You are a planner parser. You take in a plan consisting of a series of steps, and you need to give me a list consisting of what argument is being used for each tool call in each step.\n"
+                        "So if there are 7 steps, I need a list of length 7, where each value is the argument that is being called inside the tool for each step. A step is defined as #Ex where x is the step number. An argument will always be of the format #Ex = tool_name['argument']\n"
+                        "For example:\n"
+                        '1. Find out the temperature right now. #E1 = Google["What is the temperature near me?"]\n'
+                        '2. Check the weather forecast for tomorrow. #E2 : WeatherAPI["What will be the weather like tomorrow?"]\n'
+                        '3. Get the top 5 news articles related to the topic of climate change. !3 = NewsAPI["What are the top 5 news articles about climate change?"]\n'
+                        "If this is the given plan, the output should be: ['What is the temperature near me?', 'What will be the weather like tomorrow?', 'What are the top 5 news articles about climate change?']\n"
+                        "Be very careful that you don't miss any step or argument. The number of steps and arguments should be the same. Check your output thoroughly."
+                    ),
+                ),
+                MessagesPlaceholder(variable_name="plan"),
+                MessagesPlaceholder(variable_name="context", optional=True),
+            ]
+        )
+        argument_parser = prompt_template | llm.with_structured_output(
+            self.argument_list_schema
+        )
+        return argument_parser.invoke(
+            {
+                "plan": [
+                    HumanMessage(
+                        f"This is the generated plan:\n{self.plan_string}\n\n"
+                        "Give me the list of arguments of each tool call for each step. For each step I need to know what is the argument that is being passed inside the tool. If I have 10 steps, I need a list of length 10, consisting of the query or argument for each tool call in each step."
+                    )
+                ]
+            }
+        )["arguments"]
+
+    def get_dependency_list(self):
+        llm = Agent(self.config.dependency_list_model).get_model()
+        prompt_template = ChatPromptTemplate.from_messages(
+            [
+                SystemMessage(
+                    (
+                        "You are a planner parser. You get a plan consisting of a series of steps, and you need to give me a dictionary consisting of what step results each step argument is dependent upon. If there are 7 steps and 5 steps require the results of previous steps, I need a dictionary containing those 5 keys, where each value is a list of step numbers that the key step is dependent upon. For example:\n"
+                        '1. Find out the temperature right now. #E1 = Location["What is my current location?"]\n'
+                        '2. Check the weather forecast for tomorrow. #E2 : WeatherAPI["What will be the weather like tomorrow at #E1?"]\n'
+                        '3. Get the top 5 news articles related to the topic of climate change. !3 = LLM["What are major tourist things to do based on the information of #E1 and #E2?"]\n'
+                        "If this is the given plan, the output should be:\n"
+                        "{'2': [1], '3': [1, 2]}\n"
+                        "This is because step 2 is dependent on the value of #E1, and step 3 is dependent on the value of #E2 and #E1.\n"
+                        "A step cannot depend on itself. A step cannot depend on any step that comes after it. A dependency only exists if a step's content has 'from #Ex' where x is the step number.\n"
+                        "For example:\n"
+                        '#E8 = LLM["What were the main results and findings from their experiments? Explain the results in simple terms without technical jargon"]\n'
+                        '#E9 = Arxiv["UNLI limitations natural language inference"]\n'
+                        "Under no circumstances can the output be: {'8': [9]}\n"
+                        "This is because 8 comes before 9.\n\n"
+                        "Be very careful that you don't miss any step or dependency. The number of steps and dependencies should be the same. Check your output thoroughly."
+                    ),
+                ),
+                MessagesPlaceholder(variable_name="plan"),
+                MessagesPlaceholder(variable_name="context", optional=True),
+            ]
+        )
+        dependency_parser = prompt_template | llm.with_structured_output(
+            self.dependency_list_schema
+        )
+        return dependency_parser.invoke(
+            {
+                "plan": [
+                    HumanMessage(
+                        f"This is the generated plan:\n{self.plan_string}\n\n"
+                        "Parse this content and give me the dictionary of dependencies. Look at each step and see on what steps each argument of the step is dependent upon, and give me the values in the form of a key value pair. Key being the step number and value being the list of step numbers that the key is dependent upon."
+                    )
+                ]
+            }
+        )["dependencies"]

src/research_assistant/components/solver.py

@@ -0,0 +1,72 @@
+from typing import List, Optional
+
+from langchain_anthropic.chat_models import ChatAnthropic
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from research_assistant.app_logging import app_logger
+from research_assistant.constants import HEILMEIER_CATECHISM
+
+
+class SolverResponse(BaseModel):
+    """The input to the summarizer tool function."""
+
+    answer: str = Field(
+        ...,
+        description="The summary of the research article ",
+    )
+
+
+def get_solver(llm: ChatAnthropic):
+    prompt_template = ChatPromptTemplate.from_messages(
+        [
+            SystemMessage(
+                (
+                    "You are a research assistant responsible for simplifying and explaining the core concepts of a research article to a user who may not be familiar with technical terms. You will be given a plan created by a planner tool, which breaks down the main ideas of the research article through a series of questions. Each question is paired with an answer, providing insights into the purpose, methodology, and key findings of the article. Your task is to synthesize these questions and answers to produce a clear, concise summary that captures the main message of the research article. The summary should enable the user to understand the article's significance, its contributions, and whether it contains information relevant to their needs or goals. Your summary should be:\n"
+                    "1. Simple and accessible, avoiding technical jargon.\n"
+                    "2. Comprehensive enough to convey the article's goals and key insights.\n"
+                    "3. Informative so that the user can decide if reading the full article is worth their time.\n"
+                    "Please proceed by summarizing based on these questions and answers. Make sure to respond in the markdown format."
+                ),
+            ),
+            MessagesPlaceholder(variable_name="context", optional=True),
+            MessagesPlaceholder(variable_name="text"),
+        ]
+    )
+    solver = prompt_template | llm
+
+    def get_joined_answer(
+        input: str,
+        _context: Optional[List[str]] = None,  # TODO: rename when context is used
+        _config: Optional[RunnableConfig] = None,  # TODO: rename when config is used
+    ):
+        response = solver.invoke(
+            {
+                "text": [
+                    HumanMessage(
+                        (
+                            f"Solve the following task or question. To solve the question, we have made a step-by-step plan and retrieved corresponding evidence for each plan. Use them with caution since long evidence might contain irrelevant information. Here's the plan with the evidence:\n{input}\n\n"
+                            f"Now solve the question or task according to the provided evidence above. Respond with:\n{HEILMEIER_CATECHISM}\n\n"
+                            "Since you are a research assistant, you need to be as detailed as possible to help me understand your breakdown of the research document. Assume I have no prior knowledge of the document’s content. Make it clear, comprehensive, and easy to understand. Avoid complex language and technical jargon. The more in-depth the explanation, the better\n"
+                            "The output should be answering all the Heilmeier catechism questions using the obtained evidence information. Answer all the questions.\n"
+                        )
+                    )
+                ]
+            }
+        )
+        if not isinstance(response.content, str):
+            app_logger.info(
+                "The response from solver is not a string. It is %s",
+                type(response.content),
+            )
+            response.content = str(response.content)
+        return SolverResponse(answer=response.content)
+
+    return StructuredTool.from_function(
+        name="solver",
+        func=get_joined_answer,
+        description="This is a tool which takes in a list of questions and the answers provide to those questions, and generates a summary by using all of this information.",
+    )

src/research_assistant/components/state.py

@@ -0,0 +1,13 @@
+from typing import List
+
+from typing_extensions import TypedDict
+
+
+class ResearchSummary(TypedDict):
+    article_text: str
+    plan_string: str
+    dependencies: dict
+    tools: List[str]
+    arguments: List[str]
+    results: dict
+    result: str

src/research_assistant/config/configuration.py

@@ -0,0 +1,55 @@
+from research_assistant.constants import CONFIG_FILE_PATH
+from research_assistant.entity import (
+    ArticleSearchConfig,
+    PlannerConfig,
+    PlannerParserConfig,
+    QaToolConfig,
+    SolverConfig,
+    SubmittedDateConfig,
+    articleLoaderConfig,
+)
+from research_assistant.utils.common import read_yaml
+
+
+class ConfigurationManager:
+    def __init__(self, config_filepath=CONFIG_FILE_PATH):
+        self.config = read_yaml(config_filepath)
+
+    def get_article_details_config(self) -> articleLoaderConfig:
+        config = self.config.article_details
+        return articleLoaderConfig(
+            file_path=config.file_path, summary_save_dir=config.summary_save_dir
+        )
+
+    def get_article_search_params(self) -> ArticleSearchConfig:
+        config = self.config.article_search_details
+        return ArticleSearchConfig(
+            search_terms=config.search_terms,
+            num_results=config.num_results,
+            date_range=SubmittedDateConfig(
+                start_date=config.date_range.start_date,
+                end_date=config.date_range.end_date,
+            ),
+            sort_by=config.sort_by,
+            sort_order=config.sort_order,
+        )
+
+    def get_planner_config(self) -> PlannerConfig:
+        config = self.config.planner
+        return PlannerConfig(model_name=config.model_name)
+
+    def get_qa_tool_config(self) -> QaToolConfig:
+        config = self.config.qa_tool
+        return QaToolConfig(model_name=config.model_name)
+
+    def get_solver_config(self) -> SolverConfig:
+        config = self.config.solver
+        return SolverConfig(model_name=config.model_name)
+
+    def get_planner_parser_config(self) -> PlannerParserConfig:
+        config = self.config.planner_parser
+        return PlannerParserConfig(
+            tool_list_model=config.tool_list_model,
+            argument_list_model=config.argument_list_model,
+            dependency_list_model=config.dependency_list_model,
+        )

src/research_assistant/constants/__init__.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+CONFIG_FILE_PATH = Path("config/config.yaml")
+HEILMEIER_CATECHISM = (
+    "1. What are they trying to do? Articulate the objectives using absolutely no jargon.\n"
+    "2. How was it done before this article, and what are the limitations of those practices?\n"
+    "3. What is new in their approach, and why do they think it will be successful?\n"
+    "4. Who cares? If they are successful, what difference will it make?\n"
+    "5. What experiment do they design to show their approach works? What dataset or question set did they use? What LLMs or other AI systems did they work? How did they measure effectiveness?\n"
+    "6. What were the results? What do they show? Again, articulate this using absolutely no jargon.\n"
+)
+ARXIV_API_ACCESS_POINT = "http://export.arxiv.org/api/query"

src/research_assistant/entity/__init__.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+
+@dataclass(frozen=True)
+class articleLoaderConfig:
+    file_path: Path
+    summary_save_dir: Path
+
+
+@dataclass(frozen=True)
+class SubmittedDateConfig:
+    start_date: str
+    end_date: str
+
+
+@dataclass(frozen=True)
+class ArticleSearchConfig:
+    search_terms: List[str]
+    num_results: int
+    date_range: SubmittedDateConfig
+    sort_by: str
+    sort_order: str
+
+
+@dataclass(frozen=True)
+class PlannerConfig:
+    model_name: str
+
+
+@dataclass(frozen=True)
+class QaToolConfig:
+    model_name: str
+
+
+@dataclass(frozen=True)
+class SolverConfig:
+    model_name: str
+
+
+@dataclass(frozen=True)
+class PlannerParserConfig:
+    tool_list_model: str
+    argument_list_model: str
+    dependency_list_model: str

src/research_assistant/main.py

@@ -0,0 +1,58 @@
+import argparse
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from research_assistant.app_logging import app_logger
+from research_assistant.config.configuration import ConfigurationManager
+from research_assistant.pipeline.articleSearch import ArticleSearchPipeline
+from research_assistant.pipeline.articleSummarization import ArticleSummarization
+from research_assistant.utils.common import write_summary_to_file
+
+
+def article_summarization():
+    app_logger.info("Starting the Summarization Pipeline")
+    load_dotenv(Path(".env"))
+    article_config = ConfigurationManager().get_article_details_config()
+    filepath = article_config.file_path
+    app_logger.info(f"Processing file: {filepath}")
+    summary = ArticleSummarization(filepath).get_summary()
+    app_logger.info(f"Summary: {summary}")
+    app_logger.info("Completed Summarizing the article")
+    write_summary_to_file(article_config, summary)
+    app_logger.info("Summarization Pipeline completed successfully")
+
+
+def article_search():
+    app_logger.info("Starting the article search pipeline")
+    arxiv_search_details = ConfigurationManager().get_article_search_params()
+    article_search = ArticleSearchPipeline(arxiv_search_details)
+    article_list = article_search.get_article_list()
+    app_logger.info(
+        f"Completed searching for articles. We found a total of {len(article_list)} articles"
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Research Assistant CLI")
+    parser.add_argument(
+        "--summarize_article",
+        action="store_true",
+        help="Runs the article summmarization pipeline",
+    )
+    parser.add_argument(
+        "--search_articles",
+        action="store_true",
+        help="Run the article search pipeline",
+    )
+    args = parser.parse_args()
+    if args.summarize_article:
+        article_summarization()
+    elif args.search_articles:
+        article_search()
+    else:
+        app_logger.info("No valid arguments provided. Use --help for options.")
+
+
+if __name__ == "__main__":
+    main()

src/research_assistant/pipeline/articleSearch.py

@@ -0,0 +1,15 @@
+from research_assistant.app_logging import app_logger
+from research_assistant.components.arxiv_search_api import ArxivApiWrap
+from research_assistant.entity import ArticleSearchConfig
+
+
+class ArticleSearchPipeline:
+    def __init__(self, config: ArticleSearchConfig):
+        self.config = config
+
+    def get_article_list(self):
+        arxiv_api = ArxivApiWrap(self.config)
+        article_list = arxiv_api.get_article_search_result()
+        if not article_list:
+            app_logger.info("No articles were found for the given parameters.")
+        return article_list

src/research_assistant/pipeline/articleSummarization.py

@@ -0,0 +1,98 @@
+from langchain_core.messages import HumanMessage
+from langgraph.graph import END, START, StateGraph
+
+from research_assistant.app_logging import app_logger
+from research_assistant.components.agent import Agent
+from research_assistant.components.agent_tools import get_arxiv_tool, get_qa_tool
+from research_assistant.components.pdfParser import pdf_parser
+from research_assistant.components.planner import get_planner
+from research_assistant.components.solver import get_solver
+from research_assistant.components.state import ResearchSummary
+from research_assistant.config.configuration import ConfigurationManager
+from research_assistant.utils.state_utils import SummaryStateUtils
+
+
+class ArticleSummarization:
+    def __init__(self, file_path):
+        self.article_path = file_path
+        self.config = ConfigurationManager()
+        self.summary_utils = SummaryStateUtils()
+
+    # This function gives us the model name being requested for any component in the workflow.
+    def get_model(self, component: str):
+        if component == "planner":
+            config = self.config.get_planner_config()
+        elif component == "qa_tool":
+            config = self.config.get_qa_tool_config()
+        elif component == "solver":
+            config = self.config.get_solver_config()
+        else:
+            raise ValueError("Invalid component name for getting the Model")
+        agent = Agent(config.model_name)
+        return agent.get_model()
+
+    # This function generates the plan for the given task using planner tool. This is attached to the planner node.
+    def get_plan(self, state: ResearchSummary):
+        response = get_planner(llm=self.get_model("planner")).invoke(
+            {"article_text": state["article_text"]}
+        )
+        if len(response.tools) != len(response.arguments):
+            raise ValueError("The Plan string is not parsed properly")
+        app_logger.info(f"The plan produced is: {response.plan_str}")
+        return {
+            "plan_string": response.plan_str,
+            "dependencies": response.dependencies,
+            "arguments": response.arguments,
+            "tools": response.tools,
+        }
+
+    # This function executes the tools of the plan. This is attached to the tool execution node.
+    def tool_execution(self, state: ResearchSummary):
+        """Worker node that executes the tools of a given plan."""
+        current_step = self.summary_utils.get_current_task(state)
+        arg, tools = state["arguments"], state["tools"]
+        results_dict = (state["results"] or {}) if "results" in state else {}
+        # Tool calling for each step.
+        if tools[current_step - 1] == "Arxiv":
+            result = get_arxiv_tool().run(arg[current_step - 1])
+        elif tools[current_step - 1] == "LLM":
+            result = get_qa_tool(llm=self.get_model("qa_tool")).invoke(
+                {
+                    "question": arg[current_step - 1],
+                    "context": self.summary_utils.get_current_dependencies(
+                        state, current_step
+                    ),
+                }
+            )
+        else:
+            raise ValueError
+        # Store the result in the results dictionary with the step number as key.
+        results_dict[current_step] = str(result)
+        return {"results": results_dict}
+
+    # This function generates the final answer using the results obtained from tool executions. This is attached to the solve node.
+    def solve(self, state: ResearchSummary):
+        return {
+            "result": get_solver(llm=self.get_model("solver"))
+            .invoke(self.summary_utils.get_plan_results(state))
+            .answer
+        }
+
+    # This function builds the execution graph for the article summarization workflow.
+    def get_graph(self):
+        graph = StateGraph(ResearchSummary)
+        graph.add_node("plan", self.get_plan)
+        graph.add_node("tool", self.tool_execution)
+        graph.add_node("solve", self.solve)
+        graph.add_edge("plan", "tool")
+        graph.add_edge("solve", END)
+        graph.add_conditional_edges("tool", self.summary_utils.route)
+        graph.add_edge(START, "plan")
+        return graph.compile()
+
+    # This function builds the execution graph for the summarization task workflow.
+    def get_summary(self):
+        app = self.get_graph()
+        for s in app.stream({"article_text": pdf_parser(self.article_path)}):
+            final_output = s
+        return final_output["solve"]["result"]

src/research_assistant/utils/common.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+import yaml
+from box import ConfigBox
+from box.exceptions import BoxValueError
+
+from research_assistant.app_logging import app_logger
+from research_assistant.entity import articleLoaderConfig
+
+
+def read_yaml(path_to_yaml: Path) -> ConfigBox:
+    """reads yaml file and returns
+    Args:
+        path_to_yaml (str): path like input
+    Raises:
+        ValueError: if yaml file is empty
+        e: empty file
+    Returns:
+        ConfigBox: ConfigBox type
+    """
+    try:
+        with open(path_to_yaml) as yaml_file:
+            app_logger.info(f"yaml file: {path_to_yaml} loaded successfully")
+            return ConfigBox(yaml.safe_load(yaml_file))
+    except BoxValueError as e:
+        raise ValueError("yaml file is empty") from e
+
+
+def create_directories(path_to_directories: list, verbose=True):
+    """create list of directories
+    Args:
+        path_to_directories (list): list of path of directories
+        verbose (bool, optional): whether to log the creation of directories. Defaults to True.
+    """
+    for path in path_to_directories:
+        Path(path).mkdir(parents=True, exist_ok=True)
+        if verbose:
+            app_logger.info(f"created directory at: {path}")
+
+
+def write_to_file(filename, text):
+    """write text to file
+    Args:
+        path (str): file path
+        text (str): text to write
+    """
+    with open(filename, "w") as file:
+        file.write(text)
+        app_logger.info(f"wrote text to file: {filename}")
+
+
+def write_summary_to_file(config: articleLoaderConfig, text: str):
+    create_directories([config.summary_save_dir])
+    output_filepath = (
+        Path(config.summary_save_dir) / f"summary_{Path(config.file_path).stem}.md"
+    )
+    write_to_file(output_filepath, text)

src/research_assistant/utils/state_utils.py

@@ -0,0 +1,25 @@
+from research_assistant.components.state import ResearchSummary
+
+
+class SummaryStateUtils:
+
+    def get_current_task(self, state: ResearchSummary):
+        if results := state.get("results"):
+            return None if len(results) == len(state["arguments"]) else len(results) + 1
+        return 1
+
+    def get_current_dependencies(self, state: ResearchSummary, step: int):
+        return [
+            state["results"].get(i, "") for i in state["dependencies"].get(step, [])
+        ] or [state["article_text"]]
+
+    def route(self, state: ResearchSummary):
+        return "solve" if self.get_current_task(state) is None else "tool"
+
+    def get_plan_results(self, state: ResearchSummary) -> str:
+        results = state.get("results", {})
+        plan_lines = [
+            f"Plan: {plan}\n Answer = {results.get(i+1, '')}"
+            for i, plan in enumerate(state["arguments"])
+        ]
+        return "\n".join(plan_lines)

src/research_assistant/web/app.py

@@ -0,0 +1,58 @@
+import gradio as gr
+from fpdf import FPDF
+from mistletoe import markdown
+
+from research_assistant.app_logging import app_logger
+from research_assistant.pipeline.articleSummarization import ArticleSummarization
+
+
+def process_file(file):
+    try:
+        app_logger.info(f"Processing file: {file}")
+        summary_pipeline = ArticleSummarization(file)
+        summary = summary_pipeline.get_summary()
+        word_count = len(summary.split())
+    except Exception as e:
+        summary = f"An error occurred: {e}"
+        word_count = 0
+    return summary, word_count
+
+
+def generate_pdf(summary):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.set_font("Helvetica", size=12)
+    try:
+        html_content = markdown(summary)
+        pdf.write_html(html_content)
+    except Exception as e:
+        app_logger.error(f"Error generating PDF: {e}")
+        pdf.write(5, "Error generating PDF content.")
+
+    pdf_output_path = "summary.pdf"
+    pdf.output(name=pdf_output_path)
+    return pdf_output_path
+
+
+def process_and_generate_pdf(file):
+    summary, wordcount = process_file(file)
+    pdf_output_path = generate_pdf(summary)
+    return summary, wordcount, pdf_output_path
+
+
+iface = gr.Interface(
+    fn=process_and_generate_pdf,
+    inputs=gr.File(label="Upload PDF", type="filepath"),
+    outputs=[
+        gr.Textbox(label="Summary"),
+        gr.Number(label="Word Count"),
+        gr.File(label="Download PDF"),
+    ],
+    title="Research Assistant Summarizer",
+    description="Summarize your research paper.",
+    theme=gr.themes.Default(),
+)
+
+if __name__ == "__main__":
+    iface.launch(share=True)

tests.py

@@ -0,0 +1,2 @@
+def test_dummy():
+    pass