Update app.py

app.py

@@ -1,258 +1,62 @@
-from smolagents import CodeAgent, HfApiModel, tool
-import yaml
-import math
-from tools.final_answer import FinalAnswerTool
-from Gradio_UI import GradioUI
+from smolagents.agent import CodeAgent
+from smolagents.tools.core import tool
+import gradio as gr
 
+# 🔧 Объявляем функцию как инструмент
 @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.
-    
-    Args:
-        amount: Amount to invest in shekels
-        risk_profile: Risk profile (low, medium, high)
-        age: Age of the investor
-    
-    Returns:
-        Investment recommendations as formatted text
+def udp_learning_advisor(experience_level: int, learning_style: str, age: int) -> str:
     """
-    if amount <= 0:
-        return "Error: Investment amount must be a positive number."
-    
-    if age <= 0 or age > 120:
-        return "Error: Please provide a valid age."
-    
-    # Normalize risk profile
-    risk_profile = risk_profile.lower().strip()
-    valid_profiles = ["low", "medium", "high"]
-    
-    if risk_profile not in valid_profiles:
-        return "Error: Risk profile must be 'low', 'medium', or '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"}
-        ]
-    }
-    
-    # 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
-        }
-    
-    # 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
-    
-    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
-    
-    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
-    
-    # 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 += "### 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
-        
-        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"
+    Personalized learning recommendations for Unified Development Platform based on experience, learning style, and age.
+    """
+    # 🧠 Определение подхода к обучению по стилю
+    if learning_style.lower() == 'intensive':
+        plan = "Focus on hands-on projects and advanced features of the platform."
+    elif learning_style.lower() == 'balanced':
+        plan = "Combine structured tutorials with practical exercises."
+    else:  # slow or cautious
+        plan = "Start with guided walkthroughs and foundational concepts."
+
+    # 🧠 Советы по уровню опыта
+    if experience_level < 30:
+        experience_note = "Begin with basic modules like UI components and workflow automation."
+    elif experience_level < 70:
+        experience_note = "Explore integration, APIs, and process orchestration."
     else:
-        response += "Unfortunately, we cannot provide specific fund recommendations for the specified amount. Consider savings accounts or increasing your investment amount.\n\n"
-    
-    response += "### 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"
-    
-    return response
-
-# Setup agent
-final_answer = FinalAnswerTool()
-
-model = HfApiModel(
-    max_tokens=2096,
-    temperature=0.5,
-    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.
-You have access to the following tools:
+        experience_note = "Dive into customization, DevOps integration, and performance tuning."
 
-{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
-
-Use the investment_advisor tool to analyze these factors and formulate investment recommendations.
-
-To use a tool, output an action in this format:
-```py
-action = tool_name(arg1=value1, arg2=value2, ...)
-```
+    # 🧠 Подстройка по возрасту
+    if age < 25:
+        age_note = "Incorporate gamified challenges to keep engagement high."
+    elif age < 50:
+        age_note = "Use real-world business cases to reinforce concepts."
+    else:
+        age_note = "Include step-by-step explanations and documentation-heavy resources."
 
-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.
-""",
-    "react-human": "{input_string}",
-    "react-assistant": "{agent_response}",
-}
+    return f"{plan} {experience_note} {age_note}"
 
-# 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
 
-# Create the agent
+# 🧠 Агент
 agent = CodeAgent(
-    model=model,
-    tools=[final_answer, investment_advisor],
-    max_steps=3,
-    verbosity_level=1,
-    prompt_templates=prompt_templates
+    name="UDP Learning Advisor",
+    description="Advises users on learning strategies for the Unified Development Platform based on experience level, learning style, and age.",
+    tools=[udp_learning_advisor]
 )
 
-# Create a custom Gradio UI
-class InvestmentAdvisorUI(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")
-            
-            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")
-                    submit_btn = gr.Button("Get Recommendations", variant="primary")
-            
-            with gr.Row():
-                with gr.Column():
-                    recommendation_output = gr.Markdown(label="Investment 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)."
-                
-                try:
-                    recommendations = investment_advisor(int(amount), risk.lower(), int(age))
-                    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)
-        
-        demo.launch(**kwargs)
+# 🎛️ Интерфейс
+def advisor_ui(experience_level, learning_style, age):
+    return udp_learning_advisor(experience_level, learning_style, age)
+
+demo = gr.Interface(
+    fn=advisor_ui,
+    inputs=[
+        gr.Slider(0, 100, label="Experience Level"),
+        gr.Dropdown(["intensive", "balanced", "slow"], label="Learning Style"),
+        gr.Number(label="Your Age")
+    ],
+    outputs="text",
+    title="UDP Learning Advisor",
+    description="Get a personalized learning strategy for mastering the Unified Development Platform."
+)
 
-# Launch the interface
-InvestmentAdvisorUI(agent).launch()
+if __name__ == "__main__":
+    demo.launch()