added pipeline.py

pipeline.py

@@ -0,0 +1,242 @@
+# Importing dependecies
+import os
+import asyncio
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+
+
+# Setting up the API key for single project
+# 1/ create a .env file and add to it:
+# OPENAI_API_KEY = the_personal_api_key
+# 2/ load variables from .env file
+load_dotenv()
+# 3/ set up the client 
+client = AsyncOpenAI(
+    api_key=os.getenv("OPENAI_API_KEY"),
+)
+
+
+# Defining the PromptEnhancer class containing the necessary components for the Advanced Prompt Generation Pipeline
+class PromptEnhancer:
+    def __init__(self, model="gpt-4o-mini", tools_dict={}):
+        self.model = model
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.tools_dict = tools_dict
+
+    async def call_llm(self, prompt):
+        """Call the LLM with the given prompt"""
+        response = await client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", 
+                 "content": "You are an assistant designed to provide concise and specific information based solely on the given tasks.\
+                     Do not include any additional information, explanations, or context beyond what is explicitly requested."
+                 },
+                {"role": "user", 
+                 "content": prompt
+                 }
+                ],
+            temperature=0.0, # from 0 (precise and almost deterministic answer) to 2 (creative and almost random answer)
+        )
+        # counting the I/O tokens
+        self.prompt_tokens += response.usage.prompt_tokens
+        self.completion_tokens += response.usage.completion_tokens
+
+        return response.choices[0].message.content
+
+    async def analyze_input(self, basic_prompt):
+        """Analyze the input prompt to determine its key information"""
+        analysis_prompt = f"""
+        Analyze the following {{prompt}} and generate brief answers to these key information that will be beneficial to enhance the prompt: 
+        1. Main topic of the prompt 
+        2. The most convenient output format for the prompt 
+        3. Specific requirements for the prompt, if necessary
+        4. Suggested strategies to enhance the prompt for better output result
+
+        {{prompt}}: {basic_prompt}
+        
+        Your output will be only the result of the information required above in text format.
+        Do not return a general explanation of the generation process.
+        """
+        return await self.call_llm(analysis_prompt)
+
+    async def expand_instructions(self, basic_prompt, analysis):
+        """Expand the basic prompt with clear, detailed instructions"""
+        expansion_prompt = f"""
+        Based on this {{analysis}}: 
+        
+        {analysis}
+        
+        Expand the following {{basic_prompt}} following these instructions: 
+        1. Add relevant details to clarify the prompt only if necessary
+        2. Suggest an appropriate persona for the AI Model 
+        3. Generate 1-2 related examples to guide the output generation 
+        4. Suggest an optimal output length 
+        5. Use delimiter, {{ }}, to clearly indicate the parts of the input that should be concidered as variables
+
+        {{basic_prompt}}: {basic_prompt}
+               
+        Your output will be only the result of the information required above in text format and not a dictionary format.
+        Make sure the generated output maintains the sructure of a prompt for an AI Model. 
+        Make sure the generated output maintains the goal and context of the {{basic_prompt}}.
+        Do not include the instructions headers in the generated answer. 
+        Do not return a general explanation of the generation process.
+        Do not generate an answer for the prompt. 
+        """
+        return await self.call_llm(expansion_prompt)
+
+    async def decompose_task(self, expanded_prompt):
+        """Break down complex tasks into subtasks"""
+        decomposition_prompt = f"""
+        Break down the following {{prompt}} into subtasks for better output generation and follow these instructions:
+        1. Identify main task components and their corresponding subtasks
+        2. Create specific instructions for each subtask
+        3. Define success criteria for each subtask
+
+        {{prompt}}: {expanded_prompt}
+        
+        Your output will be only the result of the task required above in text format.
+        Follow the (Main-task/ Sub-task/ Instructions/ Success-criteria) format.
+        Do not return a general explanation of the generation process.
+        """
+        return await self.call_llm(decomposition_prompt)
+
+    async def add_reasoning(self, expanded_prompt):
+        """Add instructions for showing reasoning, chain-of-thought, and self-review"""
+        reasoning_prompt = f"""
+        Based on the following {{prompt}}, suggest instructions in order to guide the AI Model to:
+        1. Show reasoning through using the chain-of-thought process
+        2. Use inner-monologue only if it is recommended to hide parts of the thought process
+        3. Self-review and check for missed information
+
+        {{prompt}}: {expanded_prompt}
+        
+        Your output will be only the set of instructions in text format.
+        Do not return a general explanation of the generation process.
+        """
+        return await self.call_llm(reasoning_prompt)
+    
+    async def create_eval_criteria(self, expanded_prompt):
+        """Generate evaluation criteria for the prompt output"""
+        evaluation_prompt = f"""
+        Create evaluation criteria for assessing the quality of the output for this {{prompt}}:
+        1. List 1-3 specific criteria
+        2. Briefly explain how to measure each criterion
+
+        {{prompt}}: {expanded_prompt}
+        
+        Your output will be only the result of the information required above in text format.
+        Do not return a general explanation of the generation process.
+        """
+        return await self.call_llm(evaluation_prompt)
+    
+    async def suggest_references(self, expanded_prompt):
+        """Suggest relevant references and explain how to use them"""
+        reference_prompt = f"""
+        For the following {{prompt}}, suggest relevant reference texts or sources that could help enhance the output of the prompt if possible, 
+        and if not, do not return anything:
+        1. List 0-3 potential references
+        2. Briefly explain how to incorporate these references to enhance the prompt
+
+        {{prompt}}: {expanded_prompt}
+        
+        Your output will be only the result of the information required above in a dictionary called "References" containing the references titles as keys, 
+        and their corresponding explanation of incorporation as values. If no references will be suggested, return an empty dictionary.
+        Do not return a general explanation of the generation process.
+        """
+        return await self.call_llm(reference_prompt)
+
+    async def suggest_tools(self, expanded_prompt, tools_dict):
+        """Suggest relevant external tools or APIs"""
+        tool_prompt = f"""
+        For the following {{prompt}}, suggest relevant external tools from the provided {{tools_dict}} that can enhance the prompt for better execution. 
+        If the prompt does not require tools for its output, it is highly-recommended to not return any tools:
+        1. List 0-3 potential tools/APIs
+        2. Briefly explain how to use these tools within the prompt
+
+        {{prompt}}: {expanded_prompt}
+        {{tools_dict}}: {tools_dict}
+        
+        Your output will be only the result of the information required above in a dictionary containing the suggested tools as keys, 
+        and their corresponding way of usage with the prompt as values. If no tools will be suggested, return an empty dictionary.
+        Do not return a general explanation of the generation process.
+        """
+        return await self.call_llm(tool_prompt)
+
+    async def assemble_prompt(self, components):
+        """Assemble all components into a cohesive advanced prompt"""
+        assembly_prompt = f"""
+        Assemble all the following {{components}} into a cohesive, and well-structured advanced prompt and do not generate a response for the prompt.
+        Make sure to combine the {{reasoning_process}} and {{subtasks}} sections into one section called {{reasoning_process_and_subtasks}}.
+        
+        {{components}}: {components}
+
+        Your output will be only the result of the tasks required above,
+        which is an advanced coherent prompt generated from the combination of the given components dictionary. 
+        Keep only the {{reasoning_process_and_subtasks}} section instead of the {{reasoning_process}} and {{subtasks}} sections in the output.
+        Ensure that the assembled prompt maintains the delimiter structure of variables and the suggested persona.
+        Make sure that each sub-section of the prompt is clear and has a title.
+        The output is in plain text format and not a dictionary format.
+        Do not return a general explanation of the generation process.
+        Take the return-to-line symbol into consideration.
+        Remove the "**Expanded Prompt**" header.
+        """
+        return await self.call_llm(assembly_prompt)
+    
+    async def auto_eval(self, assembled_prompt, evaluation_criteria):
+        """Perform Auto-Evaluation and Auto-Adjustment"""
+        auto_eval_prompt = f"""
+        Perform any minor adjustments on the given {{prompt}} based on how likely its output will satisfy these {{evaluation_criteria}}.
+        Only perform minor changes if it is necessary and return the updated prompt as output.
+        If no changes are necessary, do not change the prompt and return it as output.
+        
+        {{prompt}}: {assembled_prompt}
+        {{evaluation_criteria}}: {evaluation_criteria}
+        
+        Your output will be only the result of the tasks required above, which is an updated version of the {{prompt}}, in text format.
+        Make sure to keep the {{evaluation_criteria}} in the output prompt.
+        Do not return a general explanation of the generation process.
+        Make sure there is no generated answer for the prompt. 
+        Make sure to maintain the stucture of the {{prompt}}.
+        """
+        return await self.call_llm(auto_eval_prompt)
+
+    async def enhance_prompt(self, basic_prompt, perform_eval=False):
+        """Main method to enhance a basic prompt to an advanced one"""
+        analysis = await self.analyze_input(basic_prompt)
+        expanded_prompt = await self.expand_instructions(basic_prompt, analysis)
+        
+        evaluation_criteria, references, subtasks, reasoning, tools = await asyncio.gather(
+            self.create_eval_criteria(expanded_prompt),
+            self.suggest_references(expanded_prompt),
+            self.decompose_task(expanded_prompt),
+            self.add_reasoning(expanded_prompt),
+            self.suggest_tools(expanded_prompt, tools_dict={}),
+        )
+
+        components = {
+            "expanded_prompt": expanded_prompt,
+            "references": references,
+            "subtasks": subtasks,
+            "tools": tools,
+            "reasoning_process": reasoning,
+            "evaluation_criteria": evaluation_criteria,
+            
+        }
+
+        assembled_prompt = await self.assemble_prompt(components)
+        
+        if perform_eval:
+            eveluated_prompt = await self.auto_eval(assembled_prompt, evaluation_criteria)
+            advanced_prompt = eveluated_prompt
+        else:
+            advanced_prompt = assembled_prompt
+
+        return {
+            "advanced_prompt": advanced_prompt,
+            "assembled_prompt": assembled_prompt,
+            "components": components,
+            "analysis": analysis,
+        }
+