Upload 8 files

app.py

@@ -5,115 +5,142 @@ from variables import *
 from custom_css import custom_css
 
 class GradioInterface:
-    def __init__(self, prompt_refiner: PromptRefiner, custom_css):
-        self.prompt_refiner = prompt_refiner
-        with gr.Blocks(css=custom_css, theme=gr.themes.Default()) as self.interface:
-            with gr.Column(elem_classes=["container", "title-container"]):
-                gr.Markdown("# PROMPT++")
-                gr.Markdown("### Automating Prompt Engineering by Refining your Prompts")
-                gr.Markdown("Learn how to generate an improved version of your prompts.")
-        
-            with gr.Column(elem_classes=["container", "input-container"]):
-                prompt_text = gr.Textbox(
-                    label="Type your prompt (or let it empty to see metaprompt)",
-                    lines=5
-                )
-                meta_prompt_choice = gr.Radio(
-                    metaprompt_list,
-                    label="Choose Meta Prompt",
-                    value=metaprompt_list[0],
-                    elem_classes=["no-background", "radio-group"]
-                )
-                refine_button = gr.Button("Refine Prompt")  
-                
-                with gr.Row(elem_classes=["container2"]):
-                    with gr.Accordion("Examples", open=False):
-                        gr.Examples(
-                            examples=examples,
-                            inputs=[prompt_text, meta_prompt_choice]
-                        )
-                       
-                    with gr.Accordion("Meta Prompt explanation", open=False):
-                        gr.Markdown(explanation_markdown)
-                
-            with gr.Column(elem_classes=["container", "analysis-container"]):
-                gr.Markdown(' ')
-                gr.Markdown("### Initial prompt analysis")
-                analysis_evaluation = gr.Markdown()
-                gr.Markdown("### Refined Prompt")
-                refined_prompt = gr.Textbox(
-                    label="Refined Prompt",
-                    interactive=True,
-                    show_label=True,
-                    show_copy_button=True,
-                )
-                gr.Markdown("### Explanation of Refinements")
-                explanation_of_refinements = gr.Markdown()
-            
-            with gr.Column(elem_classes=["container", "model-container"]):
-                with gr.Row():
-                    apply_model = gr.Dropdown(models,
-                        value="meta-llama/Llama-3.1-8B-Instruct",
-                        label="Choose the Model",
-                        container=False,
-                        scale=1,
-                        min_width=300
-                    )
-                    apply_button = gr.Button("Apply MetaPrompt")
+  def __init__(self, prompt_refiner: PromptRefiner, custom_css):
+      self.prompt_refiner = prompt_refiner
+      with gr.Blocks(css=custom_css, theme=gr.themes.Default()) as self.interface:
+          with gr.Column(elem_classes=["container", "title-container"]):
+              gr.Markdown("# PROMPT++")
+              gr.Markdown("### Automating Prompt Engineering by Refining your Prompts")
+              gr.Markdown("Learn how to generate an improved version of your prompts.")
+      
+          with gr.Column(elem_classes=["container", "input-container"]):
+              prompt_text = gr.Textbox(
+                  label="Type your prompt (or let it empty to see metaprompt)",
+                  lines=5
+              )
+              with gr.Row(elem_classes=["container2"]):
+                  automatic_metaprompt_button = gr.Button("Refine Prompt using automatic MetaPrompt choice")
+                  
+              with gr.Accordion("Manual Choice of Meta Prompt", open=False):
+                  meta_prompt_choice = gr.Radio(
+                      metaprompt_list,
+                      label="Choose Meta Prompt",
+                      value=metaprompt_list[0],
+                      elem_classes=["no-background", "radio-group"]
+                  )
+                  refine_button = gr.Button("Refine Prompt using manual choice") 
+                  gr.Markdown(explanation_markdown)
+                  gr.Examples(
+                      examples=examples,
+                      inputs=[prompt_text, meta_prompt_choice]
+                  )
 
-                gr.Markdown("### Prompts on choosen model")
-                with gr.Tabs():
-                    with gr.TabItem("Original Prompt Output"):
-                        original_output = gr.Markdown()
-                    with gr.TabItem("Refined Prompt Output"):
-                        refined_output = gr.Markdown()
-            with gr.Accordion("Full Response JSON", open=False, visible=True):
-                full_response_json = gr.JSON()
-                
-            refine_button.click(
-                fn=self.refine_prompt,
-                inputs=[prompt_text, meta_prompt_choice],
-                outputs=[analysis_evaluation, refined_prompt, explanation_of_refinements, full_response_json]
-            )
+                                 
+          with gr.Column(elem_classes=["container", "analysis-container"]):
+              gr.Markdown(' ')
+              gr.Markdown("### Original Prompt analysis")
+              analysis_evaluation = gr.Markdown()
+              gr.Markdown("---")
+              #MetaPrompt_analysis_evaluation= gr.Markdown("### MataPrompt used")
+              MetaPrompt_analysis = gr.Markdown("### MataPrompt used")              
+              gr.Markdown("### Refined Prompt")
+              refined_prompt = gr.Textbox(
+                  label="Refined Prompt",
+                  interactive=True,
+                  show_label=True,
+                  show_copy_button=True,
+              )
+              gr.Markdown("### Explanation of Refinements")
+              explanation_of_refinements = gr.Markdown()
+          
+          with gr.Column(elem_classes=["container", "model-container"]):
+              with gr.Row():
+                  apply_model = gr.Dropdown(models,
+                      value="meta-llama/Llama-3.1-8B-Instruct",
+                      label="Choose the Model",
+                      container=False,
+                      scale=1,
+                      min_width=300
+                  )
+                  apply_button = gr.Button("Apply Prompts")
 
-            apply_button.click(
-                fn=self.apply_prompts,
-                inputs=[prompt_text, refined_prompt, apply_model],
-                outputs=[original_output, refined_output],
-                api_name="apply_prompts"
-            )
-            gr.HTML(
-                "<p style='text-align: center; color:orange;'>⚠ This space is in progress, and we're actively working on it, so you might find some bugs! Please report any issues you have in the Community tab to help us make it better for all.</p>"
-                )
+              gr.Markdown("### Prompts on choosen model")
+              with gr.Tabs():
+                  with gr.TabItem("Original Prompt Output"):
+                      original_output = gr.Markdown()
+                  with gr.TabItem("Refined Prompt Output"):
+                      refined_output = gr.Markdown()
+          with gr.Accordion("Full Response JSON", open=False, visible=True):
+              full_response_json = gr.JSON()
 
-    def refine_prompt(self, prompt: str, meta_prompt_choice: str) -> tuple:
-        initial_prompt_evaluation, refined_prompt, explanation_refinements, full_response = self.prompt_refiner.refine_prompt(prompt, meta_prompt_choice)
-        analysis_evaluation = f"\n\n{initial_prompt_evaluation}"
-        return (
-            analysis_evaluation,
-            refined_prompt,
-            explanation_refinements,
-            full_response
-        )
+          automatic_metaprompt_button.click(
+              fn=self.automatic_metaprompt,
+              inputs=[prompt_text, meta_prompt_choice],
+              outputs=[MetaPrompt_analysis, analysis_evaluation, refined_prompt, explanation_of_refinements, full_response_json]
+          )
+          
+          refine_button.click(
+              fn=self.refine_prompt,
+              inputs=[prompt_text, meta_prompt_choice],
+              outputs=[MetaPrompt_analysis, analysis_evaluation, refined_prompt, explanation_of_refinements, full_response_json]
+          )
 
-    def apply_prompts(self, original_prompt: str, refined_prompt: str, model: str):
-        try:
-            original_output = self.prompt_refiner.apply_prompt(original_prompt, model)
-            refined_output = self.prompt_refiner.apply_prompt(refined_prompt, model)
-            return original_output, refined_output
-        except Exception as e:
-            return f"Error: {str(e)}", f"Error: {str(e)}"
+          apply_button.click(
+              fn=self.apply_prompts,
+              inputs=[prompt_text, refined_prompt, apply_model],
+              outputs=[original_output, refined_output],
+              api_name="apply_prompts"
+          )
+          gr.HTML(
+              "<p style='text-align: center; color:orange;'>⚠ This space is in progress, and we're actively working on it, so you might find some bugs! Please report any issues you have in the Community tab to help us make it better for all.</p>"
+          )
 
-    def launch(self, share=False):
-        self.interface.launch(share=share)
+  def automatic_metaprompt(self, prompt: str, meta_prompt_choice: str) -> tuple:
+      """Wrapper method to call prompt_refiner's automatic_metaprompt"""
+      metaprompt_analysis_evaluation, initial_prompt_evaluation, refined_prompt, explanation_refinements, full_response = (
+          self.prompt_refiner.automatic_metaprompt(prompt, meta_prompt_choice)
+      )
+      analysis_evaluation = f"\n\n{initial_prompt_evaluation}"
+      return (
+          metaprompt_analysis_evaluation,
+          analysis_evaluation,
+          refined_prompt,
+          explanation_refinements,
+          full_response
+      )
+
+  def refine_prompt(self, prompt: str, meta_prompt_choice: str) -> tuple:
+      """Refine the given prompt using the selected meta prompt."""
+      metaprompt_analysis_evaluation, initial_prompt_evaluation, refined_prompt, explanation_refinements, full_response = (
+          self.prompt_refiner.refine_prompt(prompt, meta_prompt_choice)
+      )
+      analysis_evaluation = f"\n\n{initial_prompt_evaluation}"
+      return (
+          metaprompt_analysis_evaluation,
+          analysis_evaluation,
+          refined_prompt,
+          explanation_refinements,
+          full_response
+      )
+
+  def apply_prompts(self, original_prompt: str, refined_prompt: str, model: str):
+      try:
+          original_output = self.prompt_refiner.apply_prompt(original_prompt, model)
+          refined_output = self.prompt_refiner.apply_prompt(refined_prompt, model)
+          return original_output, refined_output
+      except Exception as e:
+          return f"Error: {str(e)}", f"Error: {str(e)}"
+
+  def launch(self, share=False):
+      self.interface.launch(share=share)
 
 
 if __name__ == '__main__':
-    # Initialize the prompt refiner with API token
-    prompt_refiner = PromptRefiner(api_token,meta_prompts)
-    
-    # Create the Gradio interface
-    gradio_interface = GradioInterface(prompt_refiner, custom_css)
-    
-    # Launch the interface
-    gradio_interface.launch(share=True)
+  # Initialize the prompt refiner with API token
+  prompt_refiner = PromptRefiner(api_token, meta_prompts, metaprompt_explanations)
+  
+  # Create the Gradio interface
+  gradio_interface = GradioInterface(prompt_refiner, custom_css)
+  
+  # Launch the interface
+  gradio_interface.launch(share=True)

metaprompt_router.py

@@ -1,5 +1,4 @@
-metaprompt_router=
-"""
+metaprompt_router="""
 You are an AI Prompt Selection Assistant. Your task is to analyze the user's query and recommend the most appropriate metaprompt from the following list based on the nature of the request. Provide your response in a structured JSON format.
 
 **Metaprompt List:**
@@ -48,7 +47,9 @@ You are an AI Prompt Selection Assistant. Your task is to analyze the user's que
    - **Description**: Advanced reasoning and proof engineering approach. Focuses on sequential processing and context awareness.
    - **Sample**: "Analyze the historical context and impact of the Industrial Revolution on modern economic systems."
 
-For any given user query, provide your response in the following JSON format enclosed in <json> tags:
+For this given user query:
+[Insert initial prompt here]
+provide your response in the following JSON format enclosed in <json> tags:
 
 <json>
 {

prompt_refiner.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, Field, validator
 from huggingface_hub import InferenceClient
 from huggingface_hub.errors import HfHubHTTPError
 from variables import *
+from metaprompt_router import metaprompt_router
 
 class LLMResponse(BaseModel):
   initial_prompt_evaluation: str = Field(..., description="Evaluation of the initial prompt")
@@ -37,9 +38,10 @@ class LLMResponse(BaseModel):
       return v
 
 class PromptRefiner:
-  def __init__(self, api_token: str, meta_prompts: dict):
+  def __init__(self, api_token: str, meta_prompts: dict,metaprompt_explanations: dict):
       self.client = InferenceClient(token=api_token, timeout=120)
       self.meta_prompts = meta_prompts
+      self.metaprompt_explanations=metaprompt_explanations
 
   def _clean_json_string(self, content: str) -> str:
       """Clean and prepare JSON string for parsing."""
@@ -116,14 +118,103 @@ class PromptRefiner:
           "explanation_of_refinements": "",
           "response_content": {"error": error_message}
       }
+      
+  def automatic_metaprompt(self, prompt: str, meta_prompt_choice: str) -> Tuple[str, str, str, dict]:
+      """Automatically select and apply the most appropriate metaprompt for the given prompt."""
+      try:
+          # First, use the router to determine the best metaprompt
+          router_messages = [
+              {
+                  "role": "system",
+                  "content": "You are an AI Prompt Selection Assistant that helps choose the most appropriate metaprompt based on the user's query."
+              },
+              {
+                  "role": "user",
+                  "content": metaprompt_router.replace("[Insert initial prompt here]", prompt)
+              }
+          ]
+    
+          # Get router response
+          router_response = self.client.chat_completion(
+              model=prompt_refiner_model,
+              messages=router_messages,
+              max_tokens=3000,
+              temperature=0.2
+          )
+    
+          router_content = router_response.choices[0].message.content.strip()
+          
+          # Extract JSON from router response
+          json_match = re.search(r'<json>(.*?)</json>', router_content, re.DOTALL)
+          if not json_match:
+              raise ValueError("No JSON found in router response")
+              
+          router_result = json.loads(json_match.group(1))
+          
+          # Get the recommended metaprompt key
+          recommended_key = router_result["recommended_metaprompt"]["key"]
+          
+          # Use the recommended metaprompt to refine the prompt
+          selected_meta_prompt = self.meta_prompts.get(recommended_key)
+          selected_meta_prompt_explanations = self.metaprompt_explanations.get(recommended_key)
+          
+          # Now use the selected metaprompt to refine the original prompt
+          refine_messages = [
+              {
+                  "role": "system",
+                  "content": 'You are an expert at refining and extending prompts. Given a basic prompt, provide a more relevant and detailed prompt.'
+              },
+              {
+                  "role": "user",
+                  "content": selected_meta_prompt.replace("[Insert initial prompt here]", prompt)
+              }
+          ]
+    
+          response = self.client.chat_completion(
+              model=prompt_refiner_model,
+              messages=refine_messages,
+              max_tokens=3000,
+              temperature=0.8
+          )
+    
+          response_content = response.choices[0].message.content.strip()
+          result = self._parse_response(response_content)
+    
+          try:
+              llm_response = LLMResponse(**result)
+              metaprompt_analysis = f"""
+                    #### Selected MetaPrompt Analysis
+                    - <span style="color: grey; font-style: italic;">**Primary Choice**</span>: *{router_result["recommended_metaprompt"]["name"]}*
+                    - *Description*: *{router_result["recommended_metaprompt"]["description"]}*
+                    - *Why This Choice*: *{router_result["recommended_metaprompt"]["explanation"]}*
+                    
+                    #### Alternative Option
+                    - <span style="color: grey; font-style: italic;">**Secondary Choice**</span>: *{router_result["alternative_recommendation"]["name"]}*
+                    - *Why Consider This*: *{router_result["alternative_recommendation"]["explanation"]}*
+                    """
+              return (
+                  metaprompt_analysis,
+                  llm_response.initial_prompt_evaluation,
+                  llm_response.refined_prompt,
+                  llm_response.explanation_of_refinements,
+                  llm_response.dict()
+              )
+          except Exception as e:
+              print(f"Error creating LLMResponse: {e}")
+              return self._create_error_response(f"Error validating response: {str(e)}")
+    
+      except HfHubHTTPError as e:
+          return self._create_error_response("Model timeout. Please try again later.")
+      except Exception as e:
+          return self._create_error_response(f"Unexpected error: {str(e)}")
+
+
 
   def refine_prompt(self, prompt: str, meta_prompt_choice: str) -> Tuple[str, str, str, dict]:
       """Refine the given prompt using the selected meta prompt."""
       try:
-          selected_meta_prompt = self.meta_prompts.get(
-              meta_prompt_choice, 
-              self.meta_prompts["star"]
-          )
+          selected_meta_prompt = self.meta_prompts.get(meta_prompt_choice)
+          selected_meta_prompt_explanations = self.metaprompt_explanations.get(meta_prompt_choice)
           
           messages = [
               {
@@ -149,6 +240,7 @@ class PromptRefiner:
           try:
               llm_response = LLMResponse(**result)
               return (
+                  f"- **{meta_prompt_choice}**: {selected_meta_prompt_explanations}",
                   llm_response.initial_prompt_evaluation,
                   llm_response.refined_prompt,
                   llm_response.explanation_of_refinements,
@@ -166,6 +258,7 @@ class PromptRefiner:
   def _create_error_response(self, error_message: str) -> Tuple[str, str, str, dict]:
       """Create a standardized error response tuple."""
       return (
+          f"Error: {error_message}",
           f"Error: {error_message}",
           "The selected model is currently unavailable.",
           "An error occurred during processing.",