app.py

import gradio as gr
import json
from smolagents import CodeAgent, tool, Tool, FinalAnswerTool, HfApiModel, load_tool

final_answer = FinalAnswerTool()
model = HfApiModel(
    max_tokens=2096,
    temperature=0.5,
    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
    custom_role_conversions=None,
)


class ProjectScopingTool(Tool):
    """
    Handles project scoping by collecting key details such as type, domain, budget, and timeline.
    """
    def __init__(self):
        self.project_details = {
            "type": None,
            "domain": None,
            "technical_requirements": {},
            "budget_range": {},
            "timeline"
: {}
        }
    
    def collect_project_details(self, project_type, domain, budget_min, budget_max, timeline_months):
        """
        Collects and structures project details from user input.
        """
        self.project_details = {
            "type": project_type,
            "domain": domain,
            "budget_range": {"min"
: budget_min, "max": budget_max},
            "timeline": {"months": timeline_months}
        }
        return json.dumps(self.project_details, indent=2)


class TechnicalArchitectureTool(Tool):
    """
    Determines the appropriate technical architecture based on the project type.
    """
    def generate_architecture(self, project_type):
        architectures = {
            "web": {
                "frontend": ["React", "Next.js", "Tailwind"],
                "backend": ["FastAPI", "Django", "Express"],
                "database": ["PostgreSQL", "MongoDB"]
            },
            "blockchain": {
                "blockchain_type": "EVM-compatible",
                "smart_contract_language": "Solidity",
                "consensus_mechanism": "Proof of Stake"
            },
            "ai": {
                "model_type": "Transformer",
                "inference_strategy": "Cloud-based",
                "data_processing": "Distributed"
            }
        }
        return json.dumps(architectures.get(project_type, "Invalid project type"), indent=2)


class CostEstimationTool(Tool):
    """
    Estimates the cost based on the architecture complexity and timeline.
    """
    def estimate_project_cost(self, architecture_size, timeline_months):
        base_costs = {
            "development": 5000 * (architecture_size * 0.5),
            "infrastructure": 500 * (architecture_size * 0.3),
            "maintenance": 1000 * (architecture_size * 0.2)
        }
        total_cost = sum(base_costs.values())
        return json.dumps({"total_estimated_cost": total_cost, "breakdown": base_costs}, indent=2)


class DeploymentTool(Tool):
    """
    Suggests a deployment strategy based on best practices.
    """
    def generate_deployment_strategy(self):
        return json.dumps({
            "container_strategy": "Docker + Kubernetes",
            "cloud_provider": "AWS",
            "services": ["ECS", "Lambda", "S3", "RDS"],
            "ci_cd_pipeline": "GitHub Actions"
        }, indent=2)


class MeetingPreparationTool(Tool):
    """
    Provides meeting agendas depending on the project stage.
    """
    def generate_meeting_agenda(self, project_stage):
        agendas = {
            "initial_discovery": [
                "Project Vision Validation",
                "Technical Feasibility Discussion",
                "Initial Scope Definition"
            ],
            "architecture_review": [
                "Technical Architecture Walkthrough",
                "Technology Stack Validation",
                "Performance Considerations"
            ]
        }
        return json.dumps(agendas.get(project_stage, "No agenda found for this stage"), indent=2)

# Instantiate tools
scoping_tool = ProjectScopingTool()
tech_arch_tool = TechnicalArchitectureTool()
cost_tool = CostEstimationTool()
deploy_tool = DeploymentTool()
meeting_tool = MeetingPreparationTool()

# Define the agent
tools = [
    scoping_tool.collect_project_details,
    tech_arch_tool.generate_architecture,
    cost_tool.estimate_project_cost,
    deploy_tool.generate_deployment_strategy,
    meeting_tool.generate_meeting_agenda
]

agent = CodeAgent(
    model=model,
    tools=[final_answer, tools], # add your tools here (don't remove final_answer)
    max_steps=6,
    verbosity_level=1,
    name="webchainai",
    description="Sets up first project mockups"
)

# Define Gradio Interface
with gr.Blocks() as demo:
    gr.Markdown("# 🏗️ Project Scoping & Cost Estimation Tool")

    with gr.Row():
        project_type = gr.Dropdown(["web", "blockchain", "ai"], label="Select Project Type")
        domain = gr.Textbox(label="Enter Project Domain")

    with gr.Row():
        budget_min = gr.Number(label="Min Budget ($)")
        budget_max = gr.Number(label="Max Budget ($)")
        timeline_months = gr.Number(label="Timeline (Months)")

    project_output = gr.Textbox(label="Project Details", interactive=False)
    arch_output = gr.Textbox(label="Technical Architecture", interactive=False)
    cost_output = gr.Textbox(label="Estimated Cost", interactive=False)
    deploy_output = gr.Textbox(label="Deployment Strategy", interactive=False)
    meeting_output = gr.Textbox(label="Meeting Agenda", interactive=False)

    def process_inputs(p_type, dom, min_b, max_b, months):
        project_details = scoping_tool.collect_project_details(p_type, dom, min_b, max_b, months)
        architecture = tech_arch_tool.generate_architecture(p_type)
        estimated_cost = cost_tool.estimate_project_cost(len(architecture), months)
        deployment_strategy = deploy_tool.generate_deployment_strategy()
        meeting_agenda = meeting_tool.generate_meeting_agenda("initial_discovery")
        return project_details, architecture, estimated_cost, deployment_strategy, meeting_agenda

    process_button = gr.Button("Generate Estimates")
    process_button.click(process_inputs, inputs=[project_type, domain, budget_min, budget_max, timeline_months], 
                         outputs=[project_output, arch_output, cost_output, deploy_output, meeting_output])

# Launch the Gradio App
demo(agent).launch()