Initial setup with generator, gradio and server

.gitignore

@@ -0,0 +1,3 @@
+.env
+venv/
+__pycache__/

app.py

@@ -0,0 +1,4 @@
+from mcp_gradio import main
+    
+if __name__ == "__main__":
+    main()

generator.py

@@ -0,0 +1,110 @@
+
+import requests
+import os
+from dotenv import load_dotenv
+from typing import Optional
+
+load_dotenv()
+OPENAI_API_KEY=os.getenv("OPENAI_API_KEY")
+
+MODELS = {
+    "nano":"gpt-4.1-nano",
+    "mini":"gpt-4.1-mini"
+}
+
+def prompt_generator(prompt: str, tools: Optional[str] = None, model=MODELS["nano"]) -> str:
+
+    client_instruction = """Run the following prompt after you receive it: """
+
+    with open("prompts/coding.txt", "r") as file:
+        instructions = client_instruction + file.read()
+
+    if tools:
+        tools_prompt = f"""
+        The LLM/agent consuming the prompt you are creating has access to the following MCP clients/tools: {tools}.
+        For this problem, include in the prompt indications that use {tools}, as the agent will be able to invoke them while running it. 
+        The instructions related to the usage of this tools can be added as a remark at the end in a way like this:
+
+        Use [example tool] to scrape the web and find dummy data to build the tests for the software created.
+
+        If possible, provide concrete examples of how to use '{tools}' as part of your solution or instructions.
+
+        If you do not know the capabilities of the tools, use your internal knowledge base to determine it, invoke tooling like web searching if you have it available or infer it from thecontext as a last resource.
+        """
+
+        instructions += tools_prompt
+
+    headers = {
+        "Authorization": f"Bearer {OPENAI_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    data = {
+        "model": "gpt-4.1-mini",
+        "input": prompt,
+        "instructions": instructions,
+        "tool_choice":"auto"
+    }
+
+    response = requests.post(
+        url="https://api.openai.com/v1/responses",
+        headers=headers,
+        json=data
+    )
+
+    if response.status_code == 200:
+        response_json = response.json()
+
+        output = response_json.get("output", [])
+        if not output or not isinstance(output, list):
+            return "No output found in response."
+
+        first_output = output[0]
+        content = first_output.get("content", [])
+        if not content or not isinstance(content, list):
+            return "No content found in output."
+
+        first_content = content[0]
+        output_context="Run the following prompt as if it were the prompt given by the user: "
+
+        output_text = output_context + first_content.get("text", "No 'text' field found in content.")
+
+        return output_text
+
+    else:
+        return f"Request failed with status code {response.status_code}: {response.text}"
+    
+def basic(prompt: str, tools: Optional[str] = None): return prompt_generator(prompt, tools, model="nano")
+
+def no_tooling(prompt: str) -> str: return prompt_generator(prompt)
+
+def advanced(prompt: str, tools: Optional[str] = None): return prompt_generator(prompt, tools, model="mini")
+
+TOOLS = {
+    "B":basic,
+    "A":advanced,
+    "N":no_tooling
+}
+
+def prompt_tool(prompt: str, tool: str, tools: Optional[str] = None):
+    args = [prompt]
+    kwargs = {}
+    
+    if tools is not None: args.append(tools)
+
+    return TOOLS[tool](*args, **kwargs)
+
+def main():
+    prompt = """
+    I need to write a Django view for creating an apointment 
+    for a Restaurant w a lot of constraints like it being within 
+    the hours, there being tables avaiable, 
+    having enough staff to serve a customer, 
+    as well as connecting it with my existing views and url schemas. 
+    """
+    tools = "playwright"
+    print(prompt_tool(prompt, "A", tools=tools))
+
+if __name__ == "__main__":
+    main()
+

mcp_gradio.py

@@ -0,0 +1,24 @@
+import gradio as gr
+from generator import prompt_tool
+
+def main():
+    # Create a standard Gradio interface
+    with gr.Blocks() as demo:
+        gr.Markdown("# Prompt tool demo")
+        prompt = gr.Textbox(label="Prompt", placeholder="Enter your prompt here...")
+        tool = gr.Dropdown(choices=["A", "B", "N"], value="A", label="Tool", info="Select the tool type")
+        tools = gr.Textbox(label="Tools (comma-separated)", placeholder="e.g. playwright, websearch", value="playwright")
+        output = gr.Textbox(label="Output")
+        btn = gr.Button("Generate")
+
+        def call_prompt_tool(prompt, tool, tools):
+            tools_arg = tools if tools.strip() else None
+            return prompt_tool(prompt, tool, tools=tools_arg)
+
+        btn.click(call_prompt_tool, inputs=[prompt, tool, tools], outputs=output)
+
+
+    demo.launch(mcp_server=True)
+
+if __name__ == "__main__":
+    main()

mcp_server.py

@@ -0,0 +1,24 @@
+from mcp.server.fastmcp import FastMCP
+from generator import prompt_tool
+from typing import Optional
+
+mcp = FastMCP("Prompt tool")
+
+@mcp.tool()
+def mcp_prompt_tool(prompt: str, model: str, tools: Optional[str]=None):
+    """
+    Prompt tool which returns an enhancedprompt for any given task.
+    Currently only available for coding and intended for AI-enhanced IDEs.
+
+    You can choose between "A" or "B" for model—A is the advanced, using
+    gpt-4.1-mini and B is the basic using gpt-4.1-nano.
+
+    This endpoint requires a prompt (the prompt given by the user) and
+    the tooling available in the host application, so the mcp server
+    can have that information available when crafting the prompt.
+    """
+    return prompt_tool(prompt, model, tools)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(mcp.run(transport='sse'))

prompts/coding.txt

@@ -0,0 +1,45 @@
+Role Assignment:
+You are a Prompt Engineer with a PhD in crafting detailed and articulate prompts aimed at maximizing the effectiveness of Large Language Models (LLMs) and AI Agents in performing coding tasks efficiently.
+
+Task Objective:
+Your goal is to generate prompts that enable LLMs to produce precise, context-aware, and high-quality code outputs.
+
+Guidelines:
+
+1. Specificity and Detail:
+    Provide clear and detailed instructions, including the programming language, desired functionality, and any constraints.
+
+2. Structured Framework:
+    Decompose tasks into subtasks using a structured format. For example:
+
+    * Assignment: [Clearly define the main coding task]
+
+    * Notes
+
+    - [Key requirement 1]
+    - [Key requirement 2]
+    - [Key requirement 3]
+    
+    * Additional Instructions:
+    - [Instruction 1]
+    - [Instruction 2]
+
+    Feel free to modify this structure to better suit the specific task.
+
+1. Tool Specification:
+    If applicable, mention specific tools, libraries, or frameworks that should be used or avoided. Consider the fact that in the prompt that you need to refine there may be specific tooling (MCP clients) available for the agent that is replying to it that you need to ensure are available in the prompt your return as well.
+
+2. Output Format:
+    Clearly specify the desired format of the output (e.g., complete function, class, script).
+
+3. Constraints:
+    Define any constraints such as performance requirements, coding standards, or limitations on the use of certain functions or libraries.
+
+4. Evaluation:
+    After generating the prompt, review it to ensure it aligns with the guidelines above and adjust as necessary to optimize clarity and effectiveness.
+
+5. About fillers:
+    Do not add any preambulatory or closing sentences. Consider this text will be directly fed into another model just like you, thus, respond with the prompt only.
+
+6. Extra details:
+

requirements.txt

@@ -0,0 +1,3 @@
+python-dotenv
+requests
+gradio[mcp]