Update app.py

app.py

@@ -5,163 +5,170 @@ from tools.final_answer import FinalAnswerTool
 from Gradio_UI import GradioUI
 
 @tool
-def investment_advisor(amount: int, risk_profile: str, age: int) -> str:
-    """Provides investment recommendations based on the amount in shekels, risk profile, and age.
+def udp_advisor(development_phase: str, team_size: int, project_complexity: str) -> str:
+    """Provides UDP (Unified Development Platform) recommendations based on development phase, team size, and project complexity.
     
     Args:
-        amount: Amount to invest in shekels
-        risk_profile: Risk profile (low, medium, high)
-        age: Age of the investor
+        development_phase: Current phase of development (planning, development, testing, deployment, monitoring)
+        team_size: Number of team members
+        project_complexity: Project complexity level (low, medium, high)
     
     Returns:
-        Investment recommendations as formatted text
+        UDP recommendations as formatted text
     """
-    if amount <= 0:
-        return "Error: Investment amount must be a positive number."
+    if team_size <= 0 or team_size > 1000:
+        return "Error: Please provide a valid team size (1-1000)."
     
-    if age <= 0 or age > 120:
-        return "Error: Please provide a valid age."
+    # Normalize development phase
+    development_phase = development_phase.lower().strip()
+    valid_phases = ["planning", "development", "testing", "deployment", "monitoring"]
     
-    # Normalize risk profile
-    risk_profile = risk_profile.lower().strip()
-    valid_profiles = ["low", "medium", "high"]
+    if development_phase not in valid_phases:
+        return "Error: Development phase must be one of: planning, development, testing, deployment, monitoring."
     
-    if risk_profile not in valid_profiles:
-        return "Error: Risk profile must be 'low', 'medium', or 'high'."
+    # Normalize complexity
+    project_complexity = project_complexity.lower().strip()
+    valid_complexity = ["low", "medium", "high"]
     
-    # Database of Israeli funds (ETFs and mutual funds)
-    israeli_funds = {
-        "low": [
-            {"name": "KSM Tel Bond 20", "ticker": "TELBOND20", "type": "Bonds", "risk": "Low", "min_investment": 1000, "description": "ETF tracking Tel Aviv corporate bond index"},
-            {"name": "Psagot Government Shekel Bonds", "ticker": "PSAGOT-GOV", "type": "Gov Bonds", "risk": "Low", "min_investment": 500, "description": "Israeli government bonds fund"},
-            {"name": "Migdal Foreign Currency", "ticker": "MIGDAL-FOREX", "type": "Currency", "risk": "Low-medium", "min_investment": 1000, "description": "Fund investing in foreign currency and money market instruments"},
-            {"name": "Harel Deposits Basket", "ticker": "HAREL-PIKADON", "type": "Deposits", "risk": "Very low", "min_investment": 500, "description": "Fixed income bank deposits fund"}
-        ],
-        "medium": [
-            {"name": "Tachlit Tel Aviv 35", "ticker": "TA35ETF", "type": "Index", "risk": "Medium", "min_investment": 1000, "description": "ETF tracking the 35 largest companies on the Tel Aviv Stock Exchange"},
-            {"name": "Meitav Dash 50/50", "ticker": "MEITAV-50", "type": "Mixed", "risk": "Medium", "min_investment": 2000, "description": "Balanced fund with 50% stocks and 50% bonds"},
-            {"name": "Altshuler Shaham Global", "ticker": "ALTSHULER-GLOBAL", "type": "Global", "risk": "Medium", "min_investment": 5000, "description": "Fund with diversified global investments"},
-            {"name": "Analyst Corporate AA and Above", "ticker": "ANALYST-AA", "type": "Corp Bonds", "risk": "Medium", "min_investment": 2000, "description": "High-quality corporate bonds fund with AA rating and above"}
-        ],
-        "high": [
-            {"name": "Tachlit NASDAQ 100", "ticker": "TACHLIT-NDX", "type": "Technology", "risk": "High", "min_investment": 3000, "description": "ETF tracking the NASDAQ 100 index of largest non-financial companies"},
-            {"name": "KSM S&P 500", "ticker": "KSM-SP500", "type": "US", "risk": "High", "min_investment": 3000, "description": "ETF tracking the S&P 500 index"},
-            {"name": "Mor Technologies", "ticker": "MOR-TECH", "type": "Sector", "risk": "Very high", "min_investment": 5000, "description": "Fund of Israeli technology companies"},
-            {"name": "Harel Foreign Stocks", "ticker": "HAREL-GLOBAL", "type": "International", "risk": "High", "min_investment": 5000, "description": "Fund of international stocks with high growth potential"}
-        ]
-    }
+    if project_complexity not in valid_complexity:
+        return "Error: Project complexity must be 'low', 'medium', or 'high'."
     
-    # Asset allocation based on age and risk
-    def get_allocation(age, risk):
-        # Basic rule: 120 - age = % stocks (for medium risk)
-        base_stocks = max(0, min(100, 120 - age))
-        
-        if risk == "low":
-            stocks = max(0, base_stocks - 20)
-        elif risk == "high":
-            stocks = min(100, base_stocks + 20)
-        else:  # medium risk
-            stocks = base_stocks
-        
-        bonds = min(100 - stocks, 80)
-        cash = 100 - stocks - bonds
-        
-        return {
-            "stocks": stocks,
-            "bonds": bonds,
-            "cash": cash
+    # Database of UDP tools by development phase and complexity
+    udp_tools = {
+        "planning": {
+            "low": [
+                {"name": "Trello", "category": "Project Management", "complexity": "Low", "min_team_size": 1, "description": "Simple kanban board for task tracking"},
+                {"name": "GitHub Projects", "category": "Project Management", "complexity": "Low", "min_team_size": 1, "description": "Basic project management integrated with GitHub"}
+            ],
+            "medium": [
+                {"name": "Jira", "category": "Project Management", "complexity": "Medium", "min_team_size": 5, "description": "Comprehensive agile project management tool"},
+                {"name": "Azure DevOps Boards", "category": "Project Management", "complexity": "Medium", "min_team_size": 5, "description": "Project tracking with Azure integration"}
+            ],
+            "high": [
+                {"name": "Monday.com", "category": "Project Management", "complexity": "High", "min_team_size": 10, "description": "Customizable workflow platform for complex projects"},
+                {"name": "Rally", "category": "Project Management", "complexity": "High", "min_team_size": 20, "description": "Enterprise-scale agile management and portfolio planning"}
+            ]
+        },
+        "development": {
+            "low": [
+                {"name": "GitHub", "category": "Version Control", "complexity": "Low", "min_team_size": 1, "description": "Popular code hosting platform with basic CI/CD"},
+                {"name": "VS Code", "category": "IDE", "complexity": "Low", "min_team_size": 1, "description": "Lightweight, extensible code editor"}
+            ],
+            "medium": [
+                {"name": "GitLab", "category": "DevOps Platform", "complexity": "Medium", "min_team_size": 5, "description": "Integrated DevOps platform with built-in CI/CD"},
+                {"name": "JetBrains IDEs", "category": "IDE", "complexity": "Medium", "min_team_size": 1, "description": "Language-specific professional IDEs"}
+            ],
+            "high": [
+                {"name": "Bitbucket + Bamboo", "category": "Enterprise DevOps", "complexity": "High", "min_team_size": 10, "description": "Atlassian's integrated code and CI/CD solution"},
+                {"name": "GitHub Enterprise", "category": "Enterprise DevOps", "complexity": "High", "min_team_size": 20, "description": "Self-hosted, compliant GitHub with advanced security"}
+            ]
+        },
+        "testing": {
+            "low": [
+                {"name": "Jest", "category": "Testing Framework", "complexity": "Low", "min_team_size": 1, "description": "JavaScript testing framework with minimal configuration"},
+                {"name": "GitHub Actions", "category": "CI/CD", "complexity": "Low", "min_team_size": 1, "description": "Simple workflow automation integrated with GitHub"}
+            ],
+            "medium": [
+                {"name": "Jenkins", "category": "CI/CD", "complexity": "Medium", "min_team_size": 3, "description": "Flexible automation server for building, testing, and deployment"},
+                {"name": "Selenium", "category": "Testing", "complexity": "Medium", "min_team_size": 2, "description": "Browser automation for web application testing"}
+            ],
+            "high": [
+                {"name": "Azure DevOps Pipelines", "category": "CI/CD", "complexity": "High", "min_team_size": 5, "description": "Enterprise-grade pipelines with extensive integration"},
+                {"name": "SonarQube", "category": "Code Quality", "complexity": "High", "min_team_size": 5, "description": "Advanced code quality and security platform"}
+            ]
+        },
+        "deployment": {
+            "low": [
+                {"name": "Netlify", "category": "Hosting", "complexity": "Low", "min_team_size": 1, "description": "Simple deployment platform for frontend applications"},
+                {"name": "Heroku", "category": "PaaS", "complexity": "Low", "min_team_size": 1, "description": "Platform-as-a-Service with simplified deployment"}
+            ],
+            "medium": [
+                {"name": "Docker", "category": "Containerization", "complexity": "Medium", "min_team_size": 2, "description": "Container platform for application packaging"},
+                {"name": "AWS Elastic Beanstalk", "category": "PaaS", "complexity": "Medium", "min_team_size": 3, "description": "Easy-to-use service for deploying applications"}
+            ],
+            "high": [
+                {"name": "Kubernetes", "category": "Container Orchestration", "complexity": "High", "min_team_size": 5, "description": "Production-grade container orchestration"},
+                {"name": "Terraform", "category": "IaC", "complexity": "High", "min_team_size": 3, "description": "Infrastructure as Code for multi-cloud deployment"}
+            ]
+        },
+        "monitoring": {
+            "low": [
+                {"name": "Uptime Robot", "category": "Monitoring", "complexity": "Low", "min_team_size": 1, "description": "Simple uptime monitoring for websites"},
+                {"name": "Sentry", "category": "Error Tracking", "complexity": "Low", "min_team_size": 1, "description": "Application error monitoring"}
+            ],
+            "medium": [
+                {"name": "Grafana", "category": "Observability", "complexity": "Medium", "min_team_size": 2, "description": "Metrics visualization and dashboards"},
+                {"name": "New Relic", "category": "APM", "complexity": "Medium", "min_team_size": 3, "description": "Application performance monitoring"}
+            ],
+            "high": [
+                {"name": "Prometheus", "category": "Monitoring", "complexity": "High", "min_team_size": 3, "description": "Advanced metrics collection and alerting system"},
+                {"name": "Datadog", "category": "Observability", "complexity": "High", "min_team_size": 5, "description": "Full-stack observability platform"}
+            ]
         }
+    }
     
-    # Get asset allocation
-    allocation = get_allocation(age, risk_profile)
-    
-    # Find suitable funds based on available amount and allocation
-    suitable_funds = []
-    funds_for_profile = israeli_funds[risk_profile]
-    
-    # Distribute amount by asset class
-    stock_amount = amount * allocation["stocks"] / 100
-    bond_amount = amount * allocation["bonds"] / 100
-    cash_amount = amount * allocation["cash"] / 100
-    
-    # Fund recommendations
-    stock_funds = [f for f in funds_for_profile if f["type"] in ["Index", "Technology", "US", "International", "Sector"]]
-    bond_funds = [f for f in funds_for_profile if f["type"] in ["Bonds", "Gov Bonds", "Corp Bonds"]]
-    cash_funds = [f for f in funds_for_profile if f["type"] in ["Deposits", "Currency"]]
-    
-    # Build recommendations
-    recommendations = []
-    
-    if stock_amount >= 1000 and stock_funds:
-        for fund in stock_funds:
-            if fund["min_investment"] <= stock_amount:
-                amount_to_invest = min(stock_amount * 0.8, stock_amount)
-                recommendations.append({
-                    "fund": fund,
-                    "amount": math.floor(amount_to_invest / 100) * 100,
-                    "asset_class": "Stocks"
-                })
-                break
+    # Team size categorization
+    team_category = "small" if team_size < 10 else "medium" if team_size < 50 else "large"
     
-    if bond_amount >= 1000 and bond_funds:
-        for fund in bond_funds:
-            if fund["min_investment"] <= bond_amount:
-                amount_to_invest = min(bond_amount * 0.8, bond_amount)
-                recommendations.append({
-                    "fund": fund,
-                    "amount": math.floor(amount_to_invest / 100) * 100,
-                    "asset_class": "Bonds"
-                })
-                break
+    # Find suitable tools based on team size and complexity
+    suitable_tools = []
+    tools_for_phase = udp_tools[development_phase][project_complexity]
     
-    if cash_amount >= 500 and cash_funds:
-        for fund in cash_funds:
-            if fund["min_investment"] <= cash_amount:
-                amount_to_invest = min(cash_amount * 0.9, cash_amount)
-                recommendations.append({
-                    "fund": fund,
-                    "amount": math.floor(amount_to_invest / 100) * 100,
-                    "asset_class": "Cash"
-                })
-                break
+    # Filter tools by team size
+    for tool in tools_for_phase:
+        if tool["min_team_size"] <= team_size:
+            suitable_tools.append(tool)
     
     # Format response
-    response = f"## Investment Recommendations\n\n"
-    response += f"**Amount:** {amount:,} ₪\n"
-    response += f"**Age:** {age} years\n"
-    response += f"**Risk Profile:** {risk_profile.capitalize()}\n\n"
+    response = f"## UDP Tool Recommendations\n\n"
+    response += f"**Development Phase:** {development_phase.capitalize()}\n"
+    response += f"**Team Size:** {team_size} ({team_category} team)\n"
+    response += f"**Project Complexity:** {project_complexity.capitalize()}\n\n"
     
-    response += "### Recommended Asset Allocation\n"
-    response += f"- Stocks: {allocation['stocks']}% ({int(stock_amount):,} ₪)\n"
-    response += f"- Bonds: {allocation['bonds']}% ({int(bond_amount):,} ₪)\n"
-    response += f"- Cash: {allocation['cash']}% ({int(cash_amount):,} ₪)\n\n"
-    
-    if recommendations:
-        response += "### Recommended Investments\n\n"
-        total_invested = 0
+    if suitable_tools:
+        response += "### Recommended Tools\n\n"
         
-        for rec in recommendations:
-            fund = rec["fund"]
-            amount_to_invest = rec["amount"]
-            total_invested += amount_to_invest
-            
-            response += f"**{fund['name']}** ({fund['ticker']})\n"
-            response += f"- Type: {fund['type']} ({rec['asset_class']})\n"
-            response += f"- Risk: {fund['risk']}\n"
-            response += f"- Recommended amount: {amount_to_invest:,} ₪\n"
-            response += f"- Description: {fund['description']}\n\n"
-        
-        remaining = amount - total_invested
-        if remaining > 0:
-            response += f"**Remaining funds:** {remaining:,} ₪ recommended to keep in a savings account for unexpected expenses.\n\n"
+        for tool in suitable_tools:
+            response += f"**{tool['name']}**\n"
+            response += f"- Category: {tool['category']}\n"
+            response += f"- Complexity: {tool['complexity']}\n"
+            response += f"- Min Team Size: {tool['min_team_size']}\n"
+            response += f"- Description: {tool['description']}\n\n"
     else:
-        response += "Unfortunately, we cannot provide specific fund recommendations for the specified amount. Consider savings accounts or increasing your investment amount.\n\n"
+        response += "Unfortunately, we cannot provide specific tool recommendations for your team size and complexity requirements. Consider reviewing tools for a different complexity level or adjusting your team size.\n\n"
+    
+    # Additional phase-specific advice
+    if development_phase == "planning":
+        response += "### Planning Phase Tips\n"
+        response += "- Document your requirements clearly\n"
+        response += "- Set up communication channels\n"
+        response += "- Define team roles and responsibilities\n"
+    elif development_phase == "development":
+        response += "### Development Phase Tips\n"
+        response += "- Implement branch protection rules\n"
+        response += "- Use consistent code formatting\n"
+        response += "- Schedule regular code reviews\n"
+    elif development_phase == "testing":
+        response += "### Testing Phase Tips\n"
+        response += "- Automate unit and integration tests\n"
+        response += "- Establish QA processes\n"
+        response += "- Document test cases and expected outcomes\n"
+    elif development_phase == "deployment":
+        response += "### Deployment Phase Tips\n"
+        response += "- Use environment-specific configurations\n"
+        response += "- Implement rollback strategies\n"
+        response += "- Document deployment procedures\n"
+    elif development_phase == "monitoring":
+        response += "### Monitoring Phase Tips\n"
+        response += "- Set up alerts for critical metrics\n"
+        response += "- Establish incident response processes\n"
+        response += "- Regularly review logs and performance data\n"
     
-    response += "### Important Information\n"
+    response += "\n### Important Information\n"
     response += "- These are general recommendations based on the information provided.\n"
-    response += "- Before investing, it is recommended to consult with a licensed financial advisor.\n"
-    response += "- Past performance does not guarantee future returns.\n"
-    response += "- Investments involve risks, including possible loss of principal.\n"
+    response += "- Before adopting tools, assess your team's specific needs and skills.\n"
+    response += "- Consider integration capabilities with your existing toolchain.\n"
+    response += "- Training requirements should be factored into tool adoption decisions.\n"
     
     return response
 
@@ -174,19 +181,19 @@ model = HfApiModel(
     model_id='Qwen/Qwen2.5-Coder-32B-Instruct'
 )
 
-# Configure templates for the investment advisor
-investment_prompt_templates = {
-    "react-system": """You are an investment advisor who helps users make informed investment decisions in the Israeli market.
+# Configure templates for the UDP advisor
+udp_prompt_templates = {
+    "react-system": """You are a UDP (Unified Development Platform) advisor who helps users choose appropriate tools for their software development projects.
 You have access to the following tools:
 
 {tools_string}
 
-You should help the user determine where to invest their funds in shekels based on:
-1. The amount in shekels the user is willing to invest
-2. The user's risk profile (low, medium, or high)
-3. The user's age
+You should help the user determine which UDP tools are best for their project based on:
+1. The current development phase they are in (planning, development, testing, deployment, monitoring)
+2. The size of their development team
+3. The complexity of their project (low, medium, high)
 
-Use the investment_advisor tool to analyze these factors and formulate investment recommendations.
+Use the udp_advisor tool to analyze these factors and provide tool recommendations.
 
 To use a tool, output an action in this format:
 ```py
@@ -197,63 +204,92 @@ Always use Python syntax for calling tools. After using a tool, analyze the resu
 """,
     "react-human": "{input_string}",
     "react-assistant": "{agent_response}",
+    "final_answer": {
+        "pre_messages": "I'll provide you with UDP tool recommendations based on your project details.",
+        "template": "Final Answer: {answer}"
+    }
 }
 
 # Load prompt templates from file or use our templates
 try:
     with open("prompts.yaml", 'r') as stream:
         prompt_templates = yaml.safe_load(stream)
-        prompt_templates.update(investment_prompt_templates)
 except:
-    prompt_templates = investment_prompt_templates
+    prompt_templates = {}
+
+# Add our templates
+prompt_templates["react-system"] = """You are a UDP (Unified Development Platform) advisor who helps users choose appropriate tools for their software development projects.
+You have access to the following tools:
+
+{tools_string}
+
+You should help the user determine which UDP tools are best for their project based on:
+1. The current development phase they are in (planning, development, testing, deployment, monitoring)
+2. The size of their development team
+3. The complexity of their project (low, medium, high)
+
+Use the udp_advisor tool to analyze these factors and provide tool recommendations.
+
+To use a tool, output an action in this format:
+```py
+action = tool_name(arg1=value1, arg2=value2, ...)
+```
+
+Always use Python syntax for calling tools. After using a tool, analyze the result to determine what to do next. Use final_answer to return your final answer.
+"""
+prompt_templates["react-human"] = "{input_string}"
+prompt_templates["react-assistant"] = "{agent_response}"
+prompt_templates["final_answer"] = {
+    "pre_messages": "I'll provide you with UDP tool recommendations based on your project details.",
+    "template": "Final Answer: {answer}"
+}
 
 # Create the agent
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, investment_advisor],
+    tools=[final_answer, udp_advisor],
     max_steps=3,
     verbosity_level=1,
     prompt_templates=prompt_templates
 )
 
 # Create a custom Gradio UI
-class InvestmentAdvisorUI(GradioUI):
+class UDPAdvisorUI(GradioUI):
     def launch(self, **kwargs):
         import gradio as gr
         
         with gr.Blocks(theme=gr.themes.Soft()) as demo:
-            gr.Markdown("# Investment Advisor for the Israeli Market")
-            gr.Markdown("Get personalized investment recommendations based on your profile")
+            gr.Markdown("# UDP Advisor for Software Development")
+            gr.Markdown("Get personalized UDP tool recommendations based on your project profile")
             
             with gr.Row():
                 with gr.Column():
-                    amount_input = gr.Number(label="Amount to invest (in shekels)", minimum=100)
-                    risk_input = gr.Radio(["Low", "Medium", "High"], label="Risk Profile")
-                    age_input = gr.Slider(minimum=18, maximum=100, step=1, label="Your Age")
+                    phase_input = gr.Radio(["Planning", "Development", "Testing", "Deployment", "Monitoring"], label="Development Phase")
+                    team_input = gr.Number(label="Team Size", minimum=1)
+                    complexity_input = gr.Radio(["Low", "Medium", "High"], label="Project Complexity")
                     submit_btn = gr.Button("Get Recommendations", variant="primary")
             
             with gr.Row():
                 with gr.Column():
-                    recommendation_output = gr.Markdown(label="Investment Recommendations")
+                    recommendation_output = gr.Markdown(label="UDP Recommendations")
             
-            def get_recommendations(amount, risk, age):
-                if not amount or amount < 100:
-                    return "Please enter an amount of at least 100 shekels."
-                if not risk:
-                    return "Please select a risk profile."
-                if not age or age < 18:
-                    return "Please provide a valid age (18 years or older)."
+            def get_recommendations(phase, team_size, complexity):
+                if not phase:
+                    return "Please select a development phase."
+                if not team_size or team_size < 1:
+                    return "Please provide a valid team size (at least 1)."
+                if not complexity:
+                    return "Please select a project complexity level."
                 
                 try:
-                    recommendations = investment_advisor(int(amount), risk.lower(), int(age))
+                    recommendations = udp_advisor(phase.lower(), int(team_size), complexity.lower())
                     return recommendations
                 except Exception as e:
                     return f"Error generating recommendations: {str(e)}"
             
-            submit_btn.click(get_recommendations, inputs=[amount_input, risk_input, age_input], outputs=recommendation_output)
+            submit_btn.click(get_recommendations, inputs=[phase_input, team_input, complexity_input], outputs=recommendation_output)
         
         demo.launch(**kwargs)
 
 # Launch the interface
-InvestmentAdvisorUI(agent).launch()
-
+UDPAdvisorUI(agent).launch()