Spaces:
Sleeping
Sleeping
| # 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, | |
| } | |