GPT-Powered Assistant: Automate Your Research Workflows

Introduction

Navigating the dense jungle of academic research can be a daunting task. With their intricate arguments and specialized language, research papers often leave readers needing help to grasp the core message. This is where AI steps in, offering tools like the GPT-powered assistant – a powerful ally in conquering the research landscape.

Learning Objectives

• Understand how OpenAI’s GPT-3 language model is leveraged to transform research workflows through summarization and paraphrasing.
• Discover how the GPT Assistant helps researchers save time and effort by automating tedious tasks like abstract extraction and text adaptation.
• Learn how to utilize the Assistant’s customizable paraphrasing features to improve your understanding of research findings and communicate them effectively to diverse audiences.
• Explore the potential of AI-powered research tools, including fact-checking, citation generation, and personalized recommendations, to shape the future of academic exploration.

This article was published as a part of the Data Science Blogathon.

The Challenge: Decoding the Research Labyrinth

Researchers face several hurdles when dealing with research papers:

1. Grasping the essence: Deciphering complex arguments and identifying key points within a dense language can be time-consuming and challenging.
2. Summarizing efficiently: Manually summarizing papers is tedious, prone to bias, and often fails to capture the nuances of the original work.
3. Adapting for diverse audiences: Communicating research findings to different audiences requires adjusting the tone and style of the information, which can be difficult without compromising accuracy.

The Solution: A GPT Assistant to Guide Your Research Journey

The GPT Assistant, built on OpenAI’s Assistants API, tackles these challenges head-on, offering a suite of functionalities to streamline research and unlock the insights hidden within papers:

• Abstract extraction: Pinpoint the paper’s core message easily, allowing you to grasp the main research question and findings quickly.
• Paraphrasing with control: Tailor the language to your needs. Specify the desired tone (academic, creative, or even aggressive) and output length (same, double, or triple the original) for a personalized paraphrase.
• JSON output format: Integrate the paraphrased text seamlessly with other tools. The JSON format makes using the extracted information in your research workflow easy.

Under the Hood: A Technical Glimpse

Importing Libraries

• base64: for encoding binary data like PDFs.
• sys: for accessing command-line arguments.
• json: for parsing and generating JSON data.
• openai: to access OpenAI’s API.
• asyncio: for asynchronous operations (We need to use asynchronous operations because uploading the file, creating an agent, creating a thread, and running the thread, all these processes take time, and defining the functions as async enables us to run the code without errors sequentially)

Defining Asynchronous Functions

• create_file: Uploads a PDF file to OpenAI.
• create_assistant: Creates a GPT Assistant with instructions and tools.
• create_thread: Creates a new conversation thread.
• create_message: Sends a message to the Assistant within the thread.
• run_assistant: Starts the Assistant’s execution on the thread.
• extract_run: Waits for the Assistant’s run to complete.
• extract_result: Retrieves messages from the conversation thread.

Main Function

• Takes the research paper path as input.
• Uploads the file and creates a corresponding Assistant.
• Creates a thread and sends two messages to the Assistant:
  • The first message requests the abstract of the paper.
  • The second message requests a paraphrased version of the abstract with a user-specified tone and length.
• Waits for the Assistant to finish processing and extracts its responses from the thread.
• Prints the abstract and paraphrased text.
• Converts the paraphrased text into a list of sentences in JSON format.

import base64
import sys
import json
from openai import OpenAI, AsyncOpenAI
import asyncio

client = AsyncOpenAI(api_key = "")

Steps for GPT Assistant’s Operation

Let’s delve into the key steps of the GPT Assistant’s operation:

• Paper upload:  The research paper is uploaded to OpenAI as a PDF file, providing the raw material for analysis. (To run the code with a specific research paper type “python code_file_name paper_name.pdf” in the terminal)
• Assistant creation: A specialized GPT Assistant is created with specific instructions and tools. These instructions guide the assistant on how to interpret the paper, while the tools empower it with capabilities like text retrieval.
• Conversation thread: A communication channel is established between you and the assistant. This thread facilitates the exchange of requests and responses.
• User interaction: You interact with the assistant through the thread, requesting the abstract and specifying your desired paraphrasing parameters.
• Assistant execution: The assistant analyzes the paper, processes your requests, and generates the requested outputs.
• Results extraction: The assistant’s responses, including the abstract and paraphrased text, are retrieved from the conversation thread.
• JSON conversion: The paraphrased text is formatted as a list of sentences in JSON format, making it readily usable for further analysis or integration with other tools.

async def create_file(paper):
    file = await client.files.create(
        file=open(paper, "rb"),
        purpose="assistants"
    )
    print("File created and uploaded, id: ", file.id)
    return file

async def create_assistant(file):
    assistant = await client.beta.assistants.create(
        name="Research Assistant 1",
        instructions="""You are a machine learning researcher. Answer 
        questions based on the research paper. Only focus on the details 
        and information mentioned in the paper and don not consider any 
        information outside the context of the research paper.""",
        model="gpt-3.5-turbo-1106",
        tools=[{"type": "retrieval"}],
        file_ids=[file.id]
    )
    print("Assistant created, id: ", assistant.id)
    return assistant

async def create_thread():
    thread = await client.beta.threads.create()
    print("Thread created, id: ", thread.id)
    return thread

async def create_message(thread, content):
    message = await client.beta.threads.messages.create(
        thread_id=thread.id,
        role="user",
        content=content
    )
    print("User message sent!")

async def run_assistant(thread, assistant):
    run = await client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant.id,
    )
    print("Assistant Running, id: ", run.id)
    return run

async def extract_run(thread, run):
    while run.status != "completed":
        run = await client.beta.threads.runs.retrieve(
            thread_id=thread.id,
            run_id=run.id
        )
        print("Extracting run, status: ", run.status)
    print("Extracted run, status: ", run.status)

async def extract_result(thread):
    messages = await client.beta.threads.messages.list(
        thread_id=thread.id
    )
    return messages
    
if __name__ == "__main__":
    async def main():
        paper = sys.argv[1]
        file = await create_file(paper)
        assistant = await create_assistant(file)
        thread = await create_thread()
        content1 = """Please provide the abstract of the research paper. 
        The abstract should be concise and to the point. Only consider the 
        context of the research paper and do not consider any information 
        not present in it."""
        message1 = await create_message(thread, content1)
        run1 = await run_assistant(thread, assistant)
        run2 = await extract_run(thread, run1)
        messages1 = await extract_result(thread)

        for message in list(messages1.data):
            if message.role == "assistant":
                print("Abstract : " + message.content[0].text.value)
                abstract = message.content[0].text.value
                break    
            else:
                continue

        tone = input("Please enter the desired tone (Academic, Creative, or Aggressive): ")
        output_length = input("Please enter the desired output length (1x, 2x, or 3x): ")
        if output_length == "1x":
            output = "SAME IN LENGTH AS"
        elif output_length == "2x":
            output = "TWO TIMES THE LENGTH OF"
        elif output_length == "3x":
            output = "THREE TIMES THE LENGTH OF"

        content2 = f"""Text: {abstract}. \nGenerate a paraphrased version of the 
        provided text in the {tone} tone. Expand on each key point and provide 
        additional details where possible. Aim for a final output that is 
        approximately {output} the original text. Ensure that the paraphrased 
        version retains the core information and meaning while offering a more 
        detailed and comprehensive explanation."""
        message2 = await create_message(thread, content2)
        run3 = await run_assistant(thread, assistant)
        run4 = await extract_run(thread, run3)
        messages2 = await extract_result(thread)
        for message in messages2.data:
            if message.role == "assistant":
                print("Paraphrased abstract : " + message.content[0].text.value)
                paraphrased_text = message.content[0].text.value
                break 
            else:
                continue   

        # Convert paraphrased text to JSON format
        paraphrased_sentences = paraphrased_text.split(". ")
        paraphrased_json = json.dumps(paraphrased_sentences)
        print("Paraphrased JSON:", paraphrased_json)
    asyncio.run(main())

Benefits and Applications: A Powerful Tool for Research Success

The GPT Assistant offers a multitude of benefits for researchers:

• Time-saving efficiency: Automate summarization and paraphrasing tasks, freeing up valuable time for deeper analysis and critical thinking.
• Enhanced comprehension: Grasp key points and identify relevant information quickly with concise summaries and tailored paraphrases.
• Improved communication:  Effectively communicate research findings to diverse audiences by adjusting the tone and style of the information.
• Seamless integration: Leverage the JSON format to integrate the extracted insights with other research tools and platforms.

Looking Ahead: A Glimpse into the Future of Research Assistance

The GPT Assistant is just the beginning. As AI technology evolves, we can expect even more sophisticated functionalities, such as:

• Fact-checking and citation generation: Ensuring the accuracy and credibility of paraphrased information, automatically generating citations for extracted concepts.
• Automatic topic modeling and knowledge extraction: Identifying key themes, extracting relevant concepts from the paper, and creating a knowledge graph to visualize the research landscape.
• Personalized research recommendations: Suggesting relevant papers based on your current research focus and interests, tailoring the research journey to your specific needs.
• Collaborative research tools: Enabling seamless collaboration between researchers, allowing real-time co-creation and editing of summaries and paraphrases within the Assistant platform.

The GPT Assistant marks a significant step towards democratizing access to research and empowering researchers to navigate the academic landscape more efficiently and clearly. This is not just a tool; it’s a bridge between the dense world of research and the diverse audiences who seek its insights. As AI continues to evolve, we can expect this bridge to become even sturdier and more expansive, paving the way for a future where research is not just accessible but truly transformative.

Conclusion

1. The GPT Assistant is your AI-powered research partner: It cuts through dense academic language, extracts abstracts, and offers customized paraphrases that save you time and boost comprehension.
2. Tailored communication: Adapt your research findings to any audience with the Assistant’s tone and length settings, from scholarly reports to creative presentations.
3. Seamless integration: The JSON format of the paraphrased text easily plugs into your existing research workflow, maximizing the value of extracted insights.
4. The future is bright: This is just the beginning. To revolutionize your research journey, prepare for even more advanced AI functionalities, like fact-checking, citation generation, and personalized research recommendations.

Frequently Asked Questions

The media shown in this article is not owned by Analytics Vidhya and is used at the Author’s discretion.