feat: Add generate_prompt_template MCP tool

- New MCP tool generates customized smolagents prompt templates
- Fetches base templates from smolagents GitHub (code_agent.yaml or toolcalling_agent.yaml)
- Uses Gemini AI to adapt templates for specific domains and tools
- Added UI tab in app.py for easy template generation
- Returns YAML template with usage instructions
- Enables complete end-to-end workflow: generate dataset + matching prompt template

app.py

@@ -2,7 +2,7 @@
 TraceMind MCP Server - Hugging Face Space Entry Point (Track 1)
 
 This file serves as the entry point for HuggingFace Space deployment.
-Exposes 7 AI-powered MCP tools + 3 Resources + 3 Prompts via Gradio's native MCP support.
+Exposes 10 AI-powered MCP tools + 3 Resources + 3 Prompts via Gradio's native MCP support.
 
 Built on Open Source Foundation:
     🔭 TraceVerde (genai_otel_instrument) - Automatic OpenTelemetry instrumentation
@@ -36,6 +36,7 @@ Tools Provided:
     📈 get_leaderboard_summary - Get leaderboard overview statistics
     📦 get_dataset - Load SMOLTRACE datasets as JSON
     🧪 generate_synthetic_dataset - Create domain-specific test datasets
+    📝 generate_prompt_template - Generate customized smolagents prompt templates
     📤 push_dataset_to_hub - Upload datasets to HuggingFace Hub
 
 Compatible with:
@@ -71,6 +72,7 @@ from mcp_tools import (
     get_leaderboard_summary,
     get_dataset,
     generate_synthetic_dataset,
+    generate_prompt_template,
     push_dataset_to_hub
 )
 
@@ -91,7 +93,7 @@ def create_gradio_ui():
 
         **AI-Powered Analysis for Agent Evaluation Data**
 
-        This server provides **9 MCP Tools + 3 MCP Resources + 3 MCP Prompts**:
+        This server provides **10 MCP Tools + 3 MCP Resources + 3 MCP Prompts**:
 
         ### MCP Tools (AI-Powered & Optimized)
         - 📊 **Analyze Leaderboard**: Get AI-powered insights from evaluation results
@@ -102,6 +104,7 @@ def create_gradio_ui():
         - 📈 **Get Leaderboard Summary**: Get high-level leaderboard statistics (optimized for overview)
         - 📦 **Get Dataset**: Load any HuggingFace dataset as JSON for flexible analysis
         - 🧪 **Generate Synthetic Dataset**: Create domain-specific test datasets for SMOLTRACE
+        - 📝 **Generate Prompt Template**: Create customized smolagents prompt templates for your domain
         - 📤 **Push to Hub**: Upload generated datasets to HuggingFace Hub
 
         ### MCP Resources (Data Access)
@@ -638,6 +641,77 @@ def create_gradio_ui():
                     outputs=[synth_output]
                 )
 
+            # Tab: Generate Prompt Template
+            with gr.Tab("📝 Generate Prompt Template"):
+                gr.Markdown("""
+                ## Create Customized Agent Prompt Template
+
+                Generate a domain-specific prompt template based on smolagents templates.
+                This template can be used with your synthetic dataset to run SMOLTRACE evaluations.
+
+                **🎯 Use Case**: After generating a synthetic dataset, create a matching prompt template
+                that agents can use during evaluation. This ensures your evaluation setup is complete.
+
+                **Output**: Customized YAML prompt template ready for use with smolagents
+                """)
+
+                with gr.Row():
+                    with gr.Column():
+                        prompt_domain = gr.Textbox(
+                            label="Domain",
+                            placeholder="e.g., finance, healthcare, customer_support",
+                            value="travel",
+                            info="The domain/industry for the prompt template"
+                        )
+                        prompt_tools = gr.Textbox(
+                            label="Tool Names (comma-separated)",
+                            placeholder="e.g., get_weather,search_flights,book_hotel",
+                            value="get_weather,search_flights,book_hotel",
+                            info="Names of tools the agent will use",
+                            lines=2
+                        )
+                        prompt_agent_type = gr.Dropdown(
+                            label="Agent Type",
+                            choices=["tool", "code"],
+                            value="tool",
+                            info="ToolCallingAgent (tool) or CodeAgent (code)"
+                        )
+                        prompt_button = gr.Button("📝 Generate Prompt Template", variant="primary", size="lg")
+
+                    with gr.Column():
+                        prompt_output = gr.JSON(label="Generated Prompt Template (JSON)")
+
+                        gr.Markdown("""
+                        ### 📝 Next Steps
+
+                        After generation:
+                        1. **Copy the `prompt_template`** from the JSON output above
+                        2. **Save it as a YAML file** (e.g., `{domain}_agent.yaml`)
+                        3. **Include it in your HuggingFace dataset** card or repository
+                        4. **Use it with SMOLTRACE** when running evaluations
+
+                        **💡 Tip**: This template is AI-customized for your domain and tools!
+                        """)
+
+                async def run_generate_prompt_template(domain, tools, agent_type):
+                    """Generate prompt template with async support."""
+                    try:
+                        import json
+                        result = await generate_prompt_template(
+                            domain=domain,
+                            tool_names=tools,
+                            agent_type=agent_type
+                        )
+                        return json.loads(result)
+                    except Exception as e:
+                        return {"error": str(e)}
+
+                prompt_button.click(
+                    fn=run_generate_prompt_template,
+                    inputs=[prompt_domain, prompt_tools, prompt_agent_type],
+                    outputs=[prompt_output]
+                )
+
             # Tab 7: Push Dataset to Hub
             with gr.Tab("📤 Push to Hub"):
                 gr.Markdown("""
@@ -1259,8 +1333,8 @@ def create_gradio_ui():
 
                 ### What's Exposed via MCP:
 
-                #### 9 MCP Tools (AI-Powered & Optimized)
-                The nine tools above (`analyze_leaderboard`, `debug_trace`, `estimate_cost`, `compare_runs`, `get_top_performers`, `get_leaderboard_summary`, `get_dataset`, `generate_synthetic_dataset`, `push_dataset_to_hub`)
+                #### 10 MCP Tools (AI-Powered & Optimized)
+                The ten tools above (`analyze_leaderboard`, `debug_trace`, `estimate_cost`, `compare_runs`, `get_top_performers`, `get_leaderboard_summary`, `get_dataset`, `generate_synthetic_dataset`, `generate_prompt_template`, `push_dataset_to_hub`)
                 are automatically exposed as MCP tools and can be called from any MCP client.
 
                 #### 3 MCP Resources (Data Access)

mcp_tools.py

@@ -1916,3 +1916,180 @@ def _calculate_agent_type_distribution(num_tasks: int, agent_type: str) -> dict:
         tool_count = num_tasks // 2
         code_count = num_tasks - tool_count
         return {"tool": tool_count, "code": code_count}
+
+
+@gr.mcp.tool()
+async def generate_prompt_template(
+    domain: str,
+    tool_names: str,
+    agent_type: str = "tool"
+) -> str:
+    """
+    Generate customized smolagents prompt template for a specific domain and tool set.
+
+    This tool fetches the base prompt template from smolagents GitHub repository and uses
+    Gemini AI to adapt it for your specific domain and tools. The result is a ready-to-use
+    prompt template that you can use with SMOLTRACE evaluations.
+
+    **Use Case**: When you generate synthetic datasets with `generate_synthetic_dataset`,
+    use this tool to create a matching prompt template that agents can use during evaluation.
+    This ensures your evaluation setup is complete and ready to run.
+
+    **Integration**: The generated prompt template can be included in your HuggingFace dataset
+    card, making it easy for anyone to run evaluations with your dataset.
+
+    Args:
+        domain (str): The domain for the prompt template (e.g., "finance", "healthcare", "customer_support")
+        tool_names (str): Comma-separated list of tool names (e.g., "get_stock_price,calculate_roi,fetch_company_info")
+        agent_type (str): Agent type - "tool" for ToolCallingAgent or "code" for CodeAgent. Default: "tool"
+
+    Returns:
+        str: JSON response containing the customized YAML prompt template and metadata
+    """
+    try:
+        import aiohttp
+
+        # Initialize Gemini client
+        gemini_client = GeminiClient()
+
+        # Validate agent_type
+        if agent_type not in ["tool", "code"]:
+            return json.dumps({
+                "error": "agent_type must be 'tool' or 'code'",
+                "agent_type_provided": agent_type
+            }, indent=2)
+
+        # Parse tool names
+        tools = [tool.strip() for tool in tool_names.split(",") if tool.strip()]
+        if len(tools) == 0:
+            return json.dumps({
+                "error": "At least one tool name must be provided",
+                "tool_names_provided": tool_names
+            }, indent=2)
+
+        # Determine which template to fetch
+        if agent_type == "tool":
+            template_url = "https://raw.githubusercontent.com/huggingface/smolagents/refs/heads/main/src/smolagents/prompts/toolcalling_agent.yaml"
+            template_name = "ToolCallingAgent"
+        else:  # code
+            template_url = "https://raw.githubusercontent.com/huggingface/smolagents/refs/heads/main/src/smolagents/prompts/code_agent.yaml"
+            template_name = "CodeAgent"
+
+        # Fetch the base template from GitHub
+        async with aiohttp.ClientSession() as session:
+            async with session.get(template_url) as response:
+                if response.status != 200:
+                    return json.dumps({
+                        "error": f"Failed to fetch template from GitHub (status {response.status})",
+                        "template_url": template_url
+                    }, indent=2)
+
+                base_template = await response.text()
+
+        # Create customization prompt for Gemini
+        customization_prompt = f"""You are an expert at creating agent prompt templates for smolagents.
+
+I have a base {template_name} prompt template and need to customize it for a specific domain and set of tools.
+
+**Domain**: {domain}
+**Tools Available**: {", ".join(tools)}
+**Agent Type**: {template_name}
+
+**Base Template**:
+```yaml
+{base_template}
+```
+
+**Your Task**:
+1. Analyze the base template structure
+2. Customize it for the {domain} domain
+3. Integrate the provided tools ({", ".join(tools)}) into the template
+4. Add domain-specific instructions and examples
+5. Ensure the tool descriptions are clear and domain-relevant
+
+**Customization Guidelines**:
+- Keep the YAML structure intact
+- Update the introduction/system message to be domain-specific
+- Add clear descriptions for each tool in the context of the {domain} domain
+- Include domain-specific examples where appropriate
+- Maintain the same placeholder variables (e.g., {{{{tool_descriptions}}}}, {{{{tools}}}})
+- Ensure the template is immediately usable with SMOLTRACE
+
+**Output Format**: Return ONLY the customized YAML template. No explanations, no markdown code blocks, just the raw YAML content.
+
+Start your response with the YAML content immediately."""
+
+        # Call Gemini to customize the template
+        customized_template = await gemini_client.generate_content(
+            customization_prompt,
+            temperature=0.3,  # Lower temperature for more consistent formatting
+            max_output_tokens=4096
+        )
+
+        # Clean up the response (remove any markdown formatting if present)
+        customized_template = customized_template.strip()
+        if customized_template.startswith("```yaml"):
+            customized_template = customized_template.replace("```yaml\n", "").replace("```", "").strip()
+        elif customized_template.startswith("```"):
+            customized_template = customized_template.replace("```\n", "").replace("```", "").strip()
+
+        # Return response with metadata
+        return json.dumps({
+            "template_info": {
+                "domain": domain,
+                "tools": tools,
+                "agent_type": agent_type,
+                "template_name": template_name,
+                "base_template_url": template_url,
+                "customization_method": "Google Gemini 2.5 Pro"
+            },
+            "prompt_template": customized_template,
+            "usage_instructions": f"""
+# How to Use This Prompt Template
+
+## In SMOLTRACE Evaluations
+
+1. Save this template to a file (e.g., `{domain}_{agent_type}_agent.yaml`)
+2. Use it with SMOLTRACE:
+   ```python
+   from smolagents import {template_name}
+
+   agent = {template_name}(
+       tools=[...],  # Your tools: {", ".join(tools)}
+       model="openai/gpt-4",  # Or your preferred model
+       system_prompt_path="{domain}_{agent_type}_agent.yaml"
+   )
+   ```
+
+## In HuggingFace Dataset Card
+
+Add this template to your dataset's README.md:
+```markdown
+## Agent Prompt Template
+
+This dataset was designed for the following agent configuration:
+
+- **Agent Type**: {template_name}
+- **Domain**: {domain}
+- **Tools**: {", ".join(tools)}
+
+### Prompt Template (YAML)
+
+See the `prompt_template.yaml` file in this repository.
+```
+
+## Testing the Template
+
+Use this template when evaluating with the synthetic dataset you generated.
+The template is pre-configured for the {domain} domain and includes all necessary
+tool descriptions and examples.
+"""
+        }, indent=2)
+
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        return json.dumps({
+            "error": f"Failed to generate prompt template: {str(e)}",
+            "error_details": error_details
+        }, indent=2)