Upload 8 files

app.py

@@ -1,146 +1,166 @@
 import gradio as gr
 from prompt_refiner import PromptRefiner
-from variables import models, explanation_markdown
-from variables import *
+from variables import models, explanation_markdown, metaprompt_list, examples
 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:
+          # CONTAINER 1
           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.")
-      
+              
+          # CONTAINER 2
           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
+            prompt_text = gr.Textbox(label="Type your prompt (or leave empty to see metaprompt)",lines=5)
+            automatic_metaprompt_button = gr.Button("Automatic Choice for Refinement Method ")
+            #with gr.Row(elem_classes=["container2"]):                
+            MetaPrompt_analysis = gr.Markdown()
+              
+          # CONTAINER 3    
+         # with gr.Column(elem_classes=["container"]):    
+          with gr.Column(elem_classes=["container","meta-container"]):
+              meta_prompt_choice = gr.Radio(
+                  choices=metaprompt_list,
+                  label="Choose Meta Prompt",
+                  value=metaprompt_list[0],
+                  elem_classes=["no-background", "radio-group"]
               )
-              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)
+              refine_button = gr.Button("Refine Prompt")
+              with gr.Accordion("Metaprompt Explanation", open=False, visible=True): 
+                  gr.Markdown(explanation_markdown)         
                   gr.Examples(
                       examples=examples,
                       inputs=[prompt_text, meta_prompt_choice]
-                  )
-
-                                 
-          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")              
+                  )               
+              
+          with gr.Column(elem_classes=["container", "analysis-container"]):           
+              gr.Markdown(" ")
+              prompt_evaluation = gr.Markdown()  # Added this component
               gr.Markdown("### Refined Prompt")
               refined_prompt = gr.Textbox(
-                  label="Refined Prompt",
+                  label=" ",
                   interactive=True,
                   show_label=True,
                   show_copy_button=True,
               )
-              gr.Markdown("### Explanation of Refinements")
+              #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",
+                  apply_model = gr.Dropdown(
+                      choices=models,
+                      value=models[0] if models else None,
                       label="Choose the Model",
                       container=False,
                       scale=1,
                       min_width=300
                   )
                   apply_button = gr.Button("Apply Prompts")
-
-              gr.Markdown("### Prompts on choosen model")
+              
+              gr.Markdown("### Prompts on Chosen 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()
-
+      
+          # Button click handlers
           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]
+              inputs=[prompt_text],
+              outputs=[MetaPrompt_analysis, meta_prompt_choice]
           )
           
           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]
+              outputs=[
+                  prompt_evaluation,
+                  refined_prompt,
+                  explanation_of_refinements,
+                  full_response_json
+              ]
           )
-
+          
           apply_button.click(
               fn=self.apply_prompts,
               inputs=[prompt_text, refined_prompt, apply_model],
-              outputs=[original_output, refined_output],
-              api_name="apply_prompts"
+              outputs=[original_output, refined_output]
           )
+
           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 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 automatic_metaprompt(self, prompt: str) -> tuple:
+      """Handle automatic metaprompt selection"""
+      try:
+          if not prompt.strip():
+              return "Please enter a prompt to analyze.", None
+
+          metaprompt_analysis, recommended_key = self.prompt_refiner.automatic_metaprompt(prompt)
+          return metaprompt_analysis, recommended_key
+
+      except Exception as e:
+          error_message = f"Error in automatic metaprompt: {str(e)}"
+          return error_message, None
 
   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
-      )
+      """Handle manual prompt refinement"""
+      try:
+          if not prompt.strip():
+              return (
+                  "No prompt provided.",
+                  "",
+                  "",
+                  {}
+              )
+    
+          result = self.prompt_refiner.refine_prompt(prompt, meta_prompt_choice)
+          return (
+              result[0],  # initial_prompt_evaluation
+              result[1],  # refined_prompt
+              result[2],  # explanation_of_refinements
+              result[3]   # full_response
+          )
+      except Exception as e:
+          error_message = f"Error in refine_prompt: {str(e)}"
+          return error_message, "", "", {}
 
-  def apply_prompts(self, original_prompt: str, refined_prompt: str, model: str):
+  def apply_prompts(self, original_prompt: str, refined_prompt: str, model: str) -> tuple:
+      """Apply both original and refined prompts to the selected model"""
       try:
+          if not original_prompt.strip() or not refined_prompt.strip():
+              return "No prompt provided.", "No prompt provided."
+
           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)}"
+          error_message = f"Error applying prompts: {str(e)}"
+          return error_message, error_message
 
   def launch(self, share=False):
+      """Launch the Gradio interface"""
       self.interface.launch(share=share)
 
 
 if __name__ == '__main__':
-  # Initialize the prompt refiner with API token
+  from variables import api_token, meta_prompts, metaprompt_explanations
+  
+  # Initialize the prompt refiner
   prompt_refiner = PromptRefiner(api_token, meta_prompts, metaprompt_explanations)
   
-  # Create the Gradio interface
+  # Create and launch the Gradio interface
   gradio_interface = GradioInterface(prompt_refiner, custom_css)
-  
-  # Launch the interface
   gradio_interface.launch(share=True)

custom_css.py

@@ -13,7 +13,7 @@ custom_css = """
 
 .container::before {
     position: absolute;
-    top: -10px;
+    top: -14px;
     left: 20px;
     background: white;
     padding: 0 10px;
@@ -53,15 +53,19 @@ custom_css = """
 }
 
 .input-container::before { 
-    content: 'PROMPT REFINEMENT';
+    content: 'PROMPT ANALYSIS';
 }
 
 .analysis-container::before {
-    content: 'ANALYSIS';
+    content: 'PROMPT REFINEMENT';
+}
+
+.meta-container::before {
+    content: 'REFINEMENT METHOD';
 }
 
 .model-container::before {
-    content: 'MODEL APPLICATION';
+    content: 'PROMPTS APPLICATION';
 }
 
 .examples-container::before {

metaprompt_router.py

@@ -1,94 +1,130 @@
-metaprompt_router="""
+
+def generate_metaprompt_router(methods_dict):
+  # Start with the base template
+  router_template = """
 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:**
+"""
+  
+  # Add each method to the template
+  for i, (key, method) in enumerate(methods_dict.items(), 1):
+      method_template = f"""
+{i}. **{key}**
+- **Name**: {method['name']}
+- **Description**: {method['description']}
+- **Sample**: {', '.join(f'"{example}"' for example in method.get('examples', []))}
+"""
+      router_template += method_template
+  
+  # Add the output format template
+  router_template += """
+For this given user query:
+[Insert initial prompt here]
+
+Analyze the query and provide your recommendation in the following JSON format enclosed in <json> tags:
+
+<json>
+{
+"user_query": "The original query from the user",
+"recommended_metaprompt": {
+    "key": "Key of the recommended metaprompt",
+    "name": "Name of the recommended metaprompt",
+    "description": "Brief description of the metaprompt's purpose",
+    "explanation": "Detailed explanation of why this metaprompt is the best fit for this specific query, including how it addresses the query's unique requirements and challenges",
+    "similar_sample": "If available, a sample use case from the list that's most similar to the user's query",
+    "customized_sample": "A new sample specifically tailored to the user's query using this metaprompt approach"
+},
+"alternative_recommendation": {
+    "key": "Key of the second-best metaprompt option",
+    "name": "Name of the second-best metaprompt option",
+    "explanation": "Brief explanation of why this could be an alternative choice and what specific benefits it might offer for this query"
+}
+}
+</json>
+"""
+  
+  return router_template
+
+# Generate the router configuration
+#metaprompt_router = generate_metaprompt_router(methods_dict)  # methods_dict is your full file dictionary
+
+
+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 available methods. Each method has specific strengths and use cases.
+
 **Metaprompt List:**
 1. **comprehensive_multistage**
-   - **Name**: Comprehensive Multi-Stage Refinement
-   - **Description**: Use this method for a thorough, multi-stage refinement process. Ideal for complex prompts requiring in-depth analysis, exploration of alternatives, and synthesis of ideas.
-   - **Sample**: "Develop a strategic plan for a fictional company entering a new market, considering economic, cultural, and competitive factors."
-   
+- **Name**: Comprehensive Multi-Stage Refinement
+- **Description**: Use this method for a thorough, multi-stage refinement process. Ideal for complex prompts requiring in-depth analysis, exploration of alternatives, and synthesis of ideas. Best when time allows for detailed refinement and consideration of various aspects.
+- **Sample**: "Design a comprehensive educational curriculum for teaching artificial intelligence to high school students", "Develop a detailed analysis of climate change impacts on global agriculture over the next 50 years"
+
 2. **structured_roleplaying**
-   - **Name**: Structured Role-Playing Enhancement
-   - **Description**: Opt for this when you need a structured approach with emphasis on role-playing and advanced techniques. Useful for tasks benefiting from diverse perspectives and complex reasoning.
-   - **Sample**: "Simulate a debate between two historical figures on the topic of technological advancement and its impact on society."
-   
+- **Name**: Structured Role-Playing Enhancement
+- **Description**: Opt for this when you need a structured approach with emphasis on role-playing and advanced techniques. Useful for tasks benefiting from diverse perspectives and complex reasoning.
+- **Sample**: "Create a dialogue between Einstein and a modern AI researcher discussing the future of quantum computing", "Simulate a strategic planning meeting between historical business leaders solving current tech industry challenges"
+
 3. **balanced_scientific**
-   - **Name**: Balanced Scientific Structuring
-   - **Description**: Choose this for a balance between structure and advanced techniques, with a focus on role-playing. Suitable for scientific or technical prompts.
-   - **Sample**: "Explain the process of photosynthesis in plants, including the chemical reactions involved, in a way that a high school student can understand."
-   
+- **Name**: Balanced Scientific Structuring
+- **Description**: Choose this for a balance between structure and advanced techniques, with a focus on role-playing. Suitable for scientific or technical prompts.
+- **Sample**: "Explain how CRISPR gene editing technology works and its potential applications in medicine", "Analyze the psychological and neurological factors that influence decision-making in high-pressure situations"
+
 4. **quick_simplified**
-   - **Name**: Quick Simplified Refinement
-   - **Description**: Use this simplified approach for straightforward prompts or when time is limited. Focuses on essential improvements without complex techniques.
-   - **Sample**: "Summarize the main plot of 'Romeo and Juliet' in three sentences."
-   
+- **Name**: Quick Simplified Refinement
+- **Description**: Use this simplified approach for straightforward prompts or when time is limited. Focuses on essential improvements without complex techniques.
+- **Sample**: "What are the key differences between renewable and non-renewable energy sources?", "Explain the basic principles of machine learning in simple terms"
+
 5. **logical_flow**
-   - **Name**: Logical Flow Enhancement
-   - **Description**: Choose this method to analyze and improve a prompt's strengths and weaknesses, focusing on information flow. Useful for enhancing the logical structure of prompts.
-   - **Sample**: "Outline the steps needed to conduct a scientific experiment to test the effects of sunlight on plant growth."
-   
+- **Name**: Logical Flow Enhancement
+- **Description**: Choose this method to analyze and improve a prompt's strengths and weaknesses, focusing on information flow. Useful for enhancing the logical structure of prompts.
+- **Sample**: "Break down the process of implementing a sustainable urban transportation system", "Analyze the cause-and-effect relationship between social media use and mental health"
+
 6. **flexible_technique**
-   - **Name**: Flexible Technique Integration
-   - **Description**: Employ this advanced approach to combine multiple prompt engineering techniques. Ideal for complex tasks requiring both clarity and sophisticated methods.
-   - **Sample**: "Design a comprehensive marketing campaign for a new eco-friendly product, considering digital, print, and social media strategies."
-   
+- **Name**: Flexible Technique Integration
+- **Description**: Employ this advanced approach to combine multiple prompt engineering techniques. Ideal for complex tasks requiring both clarity and sophisticated methods.
+- **Sample**: "Create a comprehensive guide for starting a tech startup, including business, technical, and marketing aspects", "Design a multi-phase approach to teaching critical thinking skills in different educational contexts"
+
 7. **autoregressive_reasoning**
-   - **Name**: Autoregressive Reasoning Optimization
-   - **Description**: Utilize this method for tasks requiring careful reasoning before conclusions. Best for prompts needing detailed output formatting.
-   - **Sample**: "Solve a complex mathematical problem involving calculus, providing a step-by-step explanation of the solution process."
-   
+- **Name**: Autoregressive Reasoning Optimization
+- **Description**: Utilize this method for tasks requiring careful reasoning before conclusions. Best for prompts needing detailed output formatting.
+- **Sample**: "Develop a step-by-step analysis of market trends to predict future investment opportunities", "Create a systematic approach to debugging complex software systems"
+
 8. **mathematical_proof**
-   - **Name**: Mathematical Proof Structuring
-   - **Description**: Specialized approach for mathematical and formal proofs. Use this for tasks requiring a logical, step-by-step prompt engineering process.
-   - **Sample**: "Prove the Pythagorean theorem using a geometric approach."
-   
+- **Name**: Mathematical Proof Structuring
+- **Description**: Specialized approach for mathematical and formal proofs. Use this for tasks requiring a logical, step-by-step prompt engineering process.
+- **Sample**: "Prove the relationship between energy and mass in Einstein's E=mc²", "Demonstrate the mathematical principles behind modern encryption methods"
+
 9. **sequential_contextual**
-   - **Name**: Sequential Contextual Enhancement
-   - **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."
+- **Name**: Sequential Contextual Enhancement
+- **Description**: Advanced reasoning and proof engineering approach. Focuses on systematic prompt enhancement through structured analysis, enhancement protocols, and validation. Ideal for complex tasks requiring thorough documentation and systematic improvements.
+- **Sample**: "Create a framework for analyzing the long-term societal impacts of artificial intelligence", "Develop a systematic approach to evaluating and improving corporate sustainability practices"
+
+10. **attention_aware**
+- **Name**: Attention-Aware Positioning
+- **Description**: Token-efficient prompt optimization focusing on attention positioning and context management. Best for tasks requiring careful information placement and progressive context building while maintaining efficiency.
+- **Sample**: "Design a progressive learning curriculum that builds complex concepts from fundamental principles", "Create a narrative structure for explaining quantum physics concepts to general audiences"
 
 For this given user query:
 [Insert initial prompt here]
-provide your response in the following JSON format enclosed in <json> tags:
 
-<json>
-{
-    "user_query": "The original query from the user",
-    "recommended_metaprompt": {
-        "key": "Key of the recommended metaprompt",
-        "name": "Name of the recommended metaprompt",
-        "description": "Brief description of the metaprompt's purpose",
-        "explanation": "Detailed explanation of why this metaprompt is the best fit",
-        "similar_sample": "A sample use case from the list that's most similar to the user's query",
-        "customized_sample": "A new sample specifically tailored to the user's query using this metaprompt approach"
-    },
-    "alternative_recommendation": {
-        "key": "Key of the second-best metaprompt option",
-        "name": "Name of the second-best metaprompt option",
-        "explanation": "Brief explanation of why this could be an alternative choice"
-    }
-}
-</json>
-
-Example:
-User Query: "Help me write a comprehensive business plan for a startup"
+Analyze the query and provide your recommendation in the following JSON format enclosed in <json> tags:
 
 <json>
 {
-    "user_query": "Help me write a comprehensive business plan for a startup",
-    "recommended_metaprompt": {
-        "key": "comprehensive_multistage",
-        "name": "Comprehensive Multi-Stage Refinement",
-        "description": "Use this method for a thorough, multi-stage refinement process. Ideal for complex prompts requiring in-depth analysis, exploration of alternatives, and synthesis of ideas.",
-        "explanation": "A business plan requires thorough analysis of multiple factors, consideration of various scenarios, and synthesis of different business aspects, making this method ideal for systematic development of a comprehensive plan.",
-        "similar_sample": "Develop a strategic plan for a fictional company entering a new market, considering economic, cultural, and competitive factors.",
-        "customized_sample": "Create a detailed business plan for a startup, analyzing market opportunities, financial projections, operational strategies, and risk assessment, while considering investor requirements and industry standards."
-    },
-    "alternative_recommendation": {
-        "key": "flexible_technique",
-        "name": "Flexible Technique Integration",
-        "explanation": "This could be an alternative as it allows for integration of various business planning techniques and methodologies, though it might not provide the same level of systematic depth as the primary recommendation."
-    }
+"user_query": "The original query from the user",
+"recommended_metaprompt": {
+    "key": "Key of the recommended metaprompt",
+    "name": "Name of the recommended metaprompt",
+    "description": "Brief description of the metaprompt's purpose",
+    "explanation": "Detailed explanation of why this metaprompt is the best fit for this specific query, including how it addresses the query's unique requirements and challenges",
+    "similar_sample": "If available, a sample use case from the list that's most similar to the user's query",
+    "customized_sample": "A new sample specifically tailored to the user's query using this metaprompt approach"
+},
+"alternative_recommendation": {
+    "key": "Key of the second-best metaprompt option",
+    "name": "Name of the second-best metaprompt option",
+    "explanation": "Brief explanation of why this could be an alternative choice and what specific benefits it might offer for this query"
+}
 }
 </json>
 """

prompt_refiner.py

@@ -22,14 +22,8 @@ class LLMResponse(BaseModel):
               return {"raw_content": v}
       return v
 
-  @validator('initial_prompt_evaluation', 'refined_prompt')
+  @validator('initial_prompt_evaluation', 'refined_prompt', 'explanation_of_refinements')
   def clean_text_fields(cls, v):
-      if isinstance(v, str):
-          return v.strip().replace('\\n', '\n').replace('\\"', '"')
-      return v
-
-  @validator('explanation_of_refinements')
-  def clean_refinements(cls, v):
       if isinstance(v, str):
           return v.strip().replace('\\n', '\n').replace('\\"', '"')
       elif isinstance(v, list):
@@ -38,54 +32,55 @@ class LLMResponse(BaseModel):
       return v
 
 class PromptRefiner:
-  def __init__(self, api_token: str, meta_prompts: dict,metaprompt_explanations: 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
+      self.metaprompt_explanations = metaprompt_explanations
 
   def _clean_json_string(self, content: str) -> str:
       """Clean and prepare JSON string for parsing."""
-      content = content.replace('•', '-')  # Replace bullet points
-      content = re.sub(r'\s+', ' ', content)  # Normalize whitespace
-      content = content.replace('\\"', '"')  # Fix escaped quotes
+      content = content.replace('•', '-')
+      content = re.sub(r'\s+', ' ', content)
+      content = content.replace('\\"', '"')
       return content.strip()
 
   def _parse_response(self, response_content: str) -> dict:
       """Parse the LLM response with enhanced error handling."""
       try:
-          # Extract content between <json> tags
           json_match = re.search(r'<json>\s*(.*?)\s*</json>', response_content, re.DOTALL)
           if json_match:
               json_str = self._clean_json_string(json_match.group(1))
               try:
-                  # Try parsing the cleaned JSON
                   parsed_json = json.loads(json_str)
                   if isinstance(parsed_json, str):
                       parsed_json = json.loads(parsed_json)
-                  
+                  prompt_analysis = f"""
+                                      #### Original prompt analysis                                      
+                                      - {parsed_json.get("initial_prompt_evaluation", "")}
+                                      """
+                  explanation_of_refinements=f"""
+                                      #### Refinement Explanation
+                                      - {parsed_json.get("explanation_of_refinements", "")}
+                                      """
                   return {
-                      "initial_prompt_evaluation": parsed_json.get("initial_prompt_evaluation", ""),
+                      "initial_prompt_evaluation": prompt_analysis,
                       "refined_prompt": parsed_json.get("refined_prompt", ""),
-                      "explanation_of_refinements": parsed_json.get("explanation_of_refinements", ""),
-                      "response_content": parsed_json if isinstance(parsed_json, dict) else {"raw_content": parsed_json}
+                      "explanation_of_refinements": explanation_of_refinements,
+                      "response_content": parsed_json
                   }
               except json.JSONDecodeError:
-                  # If JSON parsing fails, try regex parsing
                   return self._parse_with_regex(json_str)
           
-          # If no JSON tags found, try regex parsing
           return self._parse_with_regex(response_content)
 
       except Exception as e:
           print(f"Error parsing response: {str(e)}")
-          print(f"Raw content: {response_content}")
           return self._create_error_dict(str(e))
 
   def _parse_with_regex(self, content: str) -> dict:
       """Parse content using regex when JSON parsing fails."""
       output = {}
       
-      # Handle explanation_of_refinements list format
       refinements_match = re.search(r'"explanation_of_refinements":\s*$(.*?)$', content, re.DOTALL)
       if refinements_match:
           refinements_str = refinements_match.group(1)
@@ -95,18 +90,15 @@ class PromptRefiner:
           ]
           output["explanation_of_refinements"] = refinements
       else:
-          # Try single string format
           pattern = r'"explanation_of_refinements":\s*"(.*?)"(?:,|\})'
           match = re.search(pattern, content, re.DOTALL)
           output["explanation_of_refinements"] = match.group(1).strip() if match else ""
 
-      # Extract other fields
       for key in ["initial_prompt_evaluation", "refined_prompt"]:
           pattern = rf'"{key}":\s*"(.*?)"(?:,|\}})'
           match = re.search(pattern, content, re.DOTALL)
           output[key] = match.group(1).strip() if match else ""
       
-      # Store the original content in a structured way
       output["response_content"] = {"raw_content": content}
       return output
 
@@ -118,11 +110,10 @@ 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."""
+
+  def automatic_metaprompt(self, prompt: str) -> Tuple[str, str]:
+      """Automatically select the most appropriate metaprompt."""
       try:
-          # First, use the router to determine the best metaprompt
           router_messages = [
               {
                   "role": "system",
@@ -134,7 +125,6 @@ class PromptRefiner:
               }
           ]
     
-          # Get router response
           router_response = self.client.chat_completion(
               model=prompt_refiner_model,
               messages=router_messages,
@@ -143,72 +133,31 @@ class PromptRefiner:
           )
     
           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"]
+          metaprompt_analysis = f"""
+              #### Selected MetaPrompt
+              - **Primary Choice**: {router_result["recommended_metaprompt"]["name"]}
+              - *Description*: {router_result["recommended_metaprompt"]["description"]}
+              - *Why This Choice*: {router_result["recommended_metaprompt"]["explanation"]}
+              - *Similar Sample*: {router_result["recommended_metaprompt"]["similar_sample"]}
+              - *Customized Sample*: {router_result["recommended_metaprompt"]["customized_sample"]}
+              
+              #### Alternative Option
+              - **Secondary Choice**: {router_result["alternative_recommendation"]["name"]}
+              - *Why Consider This*: {router_result["alternative_recommendation"]["explanation"]}
+          """
           
-          # 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
-          )
+          return metaprompt_analysis, recommended_key
     
-          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)}")
-
-
+          return f"Error in automatic metaprompt: {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."""
@@ -218,47 +167,48 @@ class PromptRefiner:
           
           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": "system",
+                  "content": 'You are an expert at refining and extending prompts.'
               },
               {
-                  "role": "user", 
+                  "role": "user",
                   "content": selected_meta_prompt.replace("[Insert initial prompt here]", prompt)
               }
           ]
-          
+    
           response = self.client.chat_completion(
               model=prompt_refiner_model,
               messages=messages,
               max_tokens=3000,
               temperature=0.8
           )
+    
+          result = self._parse_response(response.choices[0].message.content.strip())
+          llm_response = LLMResponse(**result)
+          llm_response_dico={}
+          llm_response_dico['initial_prompt']=prompt
+          llm_response_dico['meta_prompt']=meta_prompt_choice
+          llm_response_dico=llm_response_dico | llm_response.dict()
           
-          response_content = response.choices[0].message.content.strip()
-          result = self._parse_response(response_content)
-          
-          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,
-                  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.")
+          return (
+              llm_response.initial_prompt_evaluation,
+              llm_response.refined_prompt,
+              llm_response.explanation_of_refinements,
+              llm_response_dico
+          )
+    
       except Exception as e:
-          return self._create_error_response(f"Unexpected error: {str(e)}")
+          return (
+              f"Error: {str(e)}",
+              "",
+              "",
+              {}
+          )
 
-  def _create_error_response(self, error_message: str) -> Tuple[str, str, str, dict]:
+  def _create_error_response(self, error_message: str) -> Tuple[str, str, str, str, dict]:
       """Create a standardized error response tuple."""
       return (
-          f"Error: {error_message}",
+         # f"Error: {error_message}",
           f"Error: {error_message}",
           "The selected model is currently unavailable.",
           "An error occurred during processing.",
@@ -271,32 +221,14 @@ class PromptRefiner:
           messages = [
               {
                   "role": "system",
-                  "content": """You are a markdown formatting expert. Format your responses with proper spacing and structure following these rules:
-                      1. Paragraph Spacing:
-                      - Add TWO blank lines between major sections (##)
-                      - Add ONE blank line between subsections (###)
-                      - Add ONE blank line between paragraphs within sections
-                      - Add ONE blank line before and after lists
-                      - Add ONE blank line before and after code blocks
-                      - Add ONE blank line before and after blockquotes
-                      
-                      2. Section Formatting:
-                      # Title
-                      
-                      ## Major Section
-                      
-                      [blank line]
-                      Content paragraph 1
-                      [blank line]
-                      Content paragraph 2
-                      [blank line]"""
+                  "content": "You are a markdown formatting expert."
               },
               {
                   "role": "user",
                   "content": prompt
               }
           ]
-  
+
           response = self.client.chat_completion(
               model=model,
               messages=messages,
@@ -304,13 +236,11 @@ class PromptRefiner:
               temperature=0.8,
               stream=True
           )
-          
-          full_response = ""
-          for chunk in response:
-              if chunk.choices[0].delta.content is not None:
-                  full_response += chunk.choices[0].delta.content
-                  
-          return full_response.replace('\n\n', '\n').strip()
-              
+
+          return "".join(
+              chunk.choices[0].delta.content or ""
+              for chunk in response
+          ).strip()
+
       except Exception as e:
           return f"Error: {str(e)}"