Added Initial Version of Prompt Engineer

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Malhar Ujawane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,14 +1,112 @@
+# Prompt Engineer Agent
+
+![Demo Image](demo.png)
+
+
+## Overview
+This project is an **AI-powered Prompt Engineering Tool** designed to automatically enhance and optimize prompts for large language models (LLMs). Using advanced prompt engineering principles and OpenAI's GPT-4, the tool transforms basic prompts into comprehensive, well-structured instructions that yield better results.
+
+## Key Features
+- **Automated Prompt Enhancement:** Transforms basic prompts into detailed, optimized versions
+- **Multi-step Analysis:** Analyzes input, expands instructions, decomposes tasks, and adds reasoning
+- **OpenAI Integration:** Leverages GPT-4o for intelligent prompt engineering
+- **Gradio Interface:** Provides an intuitive web interface for easy interaction
+- **Evaluation System:** Includes built-in criteria for assessing prompt quality
+- **Reference Suggestions:** Recommends relevant sources to enhance prompt effectiveness
+
+## Repo Structure
+
+```
+├── .gitignore                # Files and directories to be ignored by Git
+├── LICENSE                   # License information for the project
+├── README.md                # Project documentation (this file)
+├── agent.py                 # Core prompt engineering logic
+├── app.py                   # Gradio web interface implementation
+└── requirements.txt         # Python dependencies
+```
+
+## How It Works
+
+The tool enhances prompts through several steps:
+1. **Input Analysis:** Determines key information and requirements
+2. **Instruction Expansion:** Adds clarity and detail to basic prompts
+3. **Task Decomposition:** Breaks down complex tasks into manageable subtasks
+4. **Reasoning Addition:** Incorporates chain-of-thought and self-review instructions
+5. **Reference Integration:** Suggests relevant sources and explains their use
+6. **Quality Evaluation:** Assesses and adjusts the final prompt based on specific criteria
+
+## Getting Started
+
+### Prerequisites
+- Python 3.8+
+- OpenAI API key
+
+### Installation
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/justmalhar/prompt-engineer.git
+   cd prompt-engineer-agent
+   ```
+
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Set up your OpenAI API key in the Gradio UI:
+   - Create a .env file in the project root
+   - Add your API key: `OPENAI_API_KEY=your-api-key`
+
+### Usage
+Run the Gradio interface:
+```bash
+python app.py
+```
+
+The web interface will be available at http://localhost:7860 or generated Gradio.live URL
+
+## Features in Detail
+
+### Prompt Analysis
+- Identifies main topics and requirements
+- Determines optimal output format
+- Suggests enhancement strategies
+
+### Instruction Enhancement
+- Adds relevant details and clarifications
+- Suggests appropriate AI personas
+- Includes guiding examples
+- Optimizes output length
+
+### Task Management
+- Breaks down complex prompts into subtasks
+- Creates specific instructions per subtask
+- Defines success criteria
+
+### Quality Control
+- Implements self-review mechanisms
+- Includes evaluation criteria
+- Performs automatic adjustments
+
+## Dependencies
+- gradio
+- openai
+- python-dotenv
+- fastapi
+- uvicorn
+- And more (see requirements.txt)
+
+## Credits
+This project is inspired by and adapted from [Advanced-Prompt-Generator](https://github.com/Thunderhead-exe/Advanced-Prompt-Generator) by Thunderhead-exe.
+
+
+## License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
 ---
-title: Prompt Engineer
-emoji: 🌖
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Prompt Engineer for enhancing and optimizing your prompts
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Stay Connected
+- **Twitter/X**: [@justmalhar](https://twitter.com/justmalhar) 🛠
+- **LinkedIn**: [Malhar Ujawane](https://linkedin.com/in/justmalhar) 💻
+
+Made with ❤️ and AI by [@justmalhar](https://twitter.com/justmalhar)

agent.py

@@ -0,0 +1,242 @@
+# Importing dependecies
+import os
+import asyncio
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+
+class PromptEngineer:
+    def __init__(self, temperature=0.0, tools_dict={}, api_key=None, base_url=None):
+        self.model = "gpt-4o"
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.tools_dict = tools_dict
+        
+        # Initialize OpenAI client with provided credentials
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url if base_url else "https://api.openai.com/v1"
+        )
+
+    async def call_llm(self, prompt):
+        """Call the LLM with the given prompt"""
+        try:
+            response = await self.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,
+            )
+            # 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
+        except Exception as e:
+            raise Exception(f"Error calling OpenAI API: {str(e)}")
+
+    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.
+
+        Make it detailed using all markdown formatting properties without starting any markdown blocks. Use headings, lists, bold, italics, strike throughs, latex, tables and google searches related to the topic or keyword
+        Never use below words or minimize the use:
+
+        delve, dive, deep, (most common) tapestry, intriguing, holistic, intersection, not only ... but ... (standard inversions), dancing metaphores,Site specific: (shipping) - navigate into, sail into the future(research) - ethical considerations, area, realm, in the field of (even if it already knows the field), in the <> of (completely unecessary), in the age of, in the search of.At the end of almost every long essay prompt: Paragraph idea: Save the world, make the world better, in the future, it is essential to <>.In essence, may seem counterintuitive
+
+        """
+        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,
+        }

app.py

@@ -0,0 +1,83 @@
+import gradio as gr
+import os 
+import time 
+import asyncio
+from agent import PromptEngineer
+
+async def engineer_prompt(input_prompt, api_key, temperature=0.0):
+    if not api_key:
+        return "Please provide an API key"
+    
+    try:
+        enhancer = PromptEngineer(temperature=temperature, api_key=api_key)
+        start_time = time.time()
+        result = await enhancer.enhance_prompt(input_prompt, perform_eval=False)
+        elapsed_time = time.time() - start_time
+
+        return result["advanced_prompt"]
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # Prompt Engineer
+    Transform your prompts into powerful, precise instructions using AI-driven optimization
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            api_key = gr.Textbox(
+                label="API Key", 
+                placeholder="sk-...", 
+                type="password",
+                info="Required: Enter your API key"
+            )
+            temperature = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.0,
+                step=0.1,
+                label="Temperature",
+                info="Recommended: Temperature=0.0"
+            )
+            
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_prompt = gr.Textbox(
+                lines=10,
+                placeholder="Enter your prompt here...",
+                label="Input Prompt",
+                info="Enter the prompt you want to engineer"
+            )
+            
+        with gr.Column(scale=1):
+            output_prompt = gr.Textbox(
+                lines=20,
+                label="Engineered Prompt",
+                show_copy_button=True,
+                autoscroll=False,
+                info="Your engineered prompt will appear here"
+            )
+    
+    submit_btn = gr.Button("Engineer Prompt", variant="primary")
+    submit_btn.click(
+        fn=engineer_prompt,
+        inputs=[input_prompt, api_key, temperature],
+        outputs=output_prompt
+    )
+    
+    gr.Markdown("""
+    ### Best Practices
+    - Be specific and clear in your input prompt
+    - Use temperature 0.0 for consistent, focused results
+    - Increase temperature up to 1.0 for more creative variations
+    - Review and iterate on engineered prompts for optimal results
+    """)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )

requirements.txt

@@ -0,0 +1,61 @@
+aiohttp==3.9.5
+aiosignal==1.3.1
+annotated-types==0.7.0
+anyio==4.4.0
+attrs==23.2.0
+certifi==2024.7.4
+charset-normalizer==3.3.2
+click==8.1.7
+distro==1.9.0
+dnspython==2.6.1
+email_validator==2.2.0
+fastapi==0.111.1
+fastapi-cli==0.0.4
+frozenlist==1.4.1
+gradio==4.19.2
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+huggingface_hub==0.22.2
+idna==3.7
+Jinja2==3.1.4
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.2.10
+langchain-core==0.2.22
+langchain-openai==0.1.17
+langchain-text-splitters==0.2.2
+langsmith==0.1.93
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+multidict==6.0.5
+numpy==1.26.4
+openai==1.35.15
+orjson==3.10.6
+packaging==24.1
+pydantic==2.8.2
+pydantic_core==2.20.1
+Pygments==2.18.0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+PyYAML==6.0.1
+regex==2024.5.15
+requests==2.32.3
+rich==13.7.1
+shellingham==1.5.4
+sniffio==1.3.1
+SQLAlchemy==2.0.31
+starlette==0.37.2
+tenacity==8.5.0
+tiktoken==0.7.0
+tqdm==4.66.4
+typer==0.12.3
+typing_extensions==4.12.2
+urllib3==2.2.2
+uvicorn==0.30.3
+uvloop==0.19.0
+watchfiles==0.22.0
+websockets<12.0,>=10.0
+yarl==1.9.4