Create app.py

app.py

@@ -0,0 +1,419 @@
+import gradio as gr
+import MetaTrader5 as mt5
+import pandas as pd
+from datetime import datetime
+from smolagents import CodeAgent, HfApiModel, tool
+import json
+from typing import Dict, List, Optional
+
+# Custom MetaTrader Tools
+@tool
+def connect_mt5(login: int, password: str, server: str) -> str:
+    """
+    Connect to MetaTrader 5 terminal
+    
+    Args:
+        login: MT5 account login number
+        password: MT5 account password  
+        server: MT5 server name
+    
+    Returns:
+        Connection status message
+    """
+    try:
+        if not mt5.initialize():
+            return f"Failed to initialize MT5: {mt5.last_error()}"
+        
+        if not mt5.login(login, password=password, server=server):
+            return f"Failed to connect to account {login}: {mt5.last_error()}"
+            
+        return f"Successfully connected to MT5 account {login}"
+    except Exception as e:
+        return f"Error connecting to MT5: {str(e)}"
+
+@tool
+def get_account_info() -> str:
+    """
+    Get MetaTrader 5 account information
+    
+    Returns:
+        Account information as formatted string
+    """
+    try:
+        account_info = mt5.account_info()
+        if account_info is None:
+            return "Failed to get account info. Please ensure you're connected to MT5."
+        
+        info_dict = account_info._asdict()
+        formatted_info = "=== ACCOUNT INFORMATION ===\n"
+        formatted_info += f"Login: {info_dict['login']}\n"
+        formatted_info += f"Server: {info_dict['server']}\n"
+        formatted_info += f"Name: {info_dict['name']}\n"
+        formatted_info += f"Company: {info_dict['company']}\n"
+        formatted_info += f"Currency: {info_dict['currency']}\n"
+        formatted_info += f"Balance: {info_dict['balance']:.2f}\n"
+        formatted_info += f"Equity: {info_dict['equity']:.2f}\n"
+        formatted_info += f"Margin: {info_dict['margin']:.2f}\n"
+        formatted_info += f"Free Margin: {info_dict['margin_free']:.2f}\n"
+        formatted_info += f"Margin Level: {info_dict['margin_level']:.2f}%\n"
+        formatted_info += f"Profit: {info_dict['profit']:.2f}\n"
+        
+        return formatted_info
+    except Exception as e:
+        return f"Error getting account info: {str(e)}"
+
+@tool
+def get_closed_trades(days_back: int = 30) -> str:
+    """
+    Get closed trades from MetaTrader 5
+    
+    Args:
+        days_back: Number of days to look back for trades (default: 30)
+    
+    Returns:
+        Formatted string of closed trades
+    """
+    try:
+        from datetime import datetime, timedelta
+        
+        # Calculate date range
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+        
+        # Get deals (closed trades)
+        deals = mt5.history_deals_get(start_date, end_date)
+        
+        if deals is None or len(deals) == 0:
+            return f"No closed trades found in the last {days_back} days."
+        
+        # Convert to DataFrame for easier handling
+        df = pd.DataFrame(list(deals), columns=deals[0]._asdict().keys())
+        
+        # Filter only actual trades (exclude balance operations)
+        trade_deals = df[df['type'].isin([0, 1])]  # 0=buy, 1=sell
+        
+        if len(trade_deals) == 0:
+            return f"No trading deals found in the last {days_back} days."
+        
+        formatted_trades = f"=== CLOSED TRADES (Last {days_back} days) ===\n"
+        formatted_trades += f"Total deals: {len(trade_deals)}\n\n"
+        
+        for _, deal in trade_deals.iterrows():
+            deal_type = "BUY" if deal['type'] == 0 else "SELL"
+            deal_time = datetime.fromtimestamp(deal['time'])
+            
+            formatted_trades += f"Ticket: {deal['ticket']}\n"
+            formatted_trades += f"Symbol: {deal['symbol']}\n"
+            formatted_trades += f"Type: {deal_type}\n"
+            formatted_trades += f"Volume: {deal['volume']:.2f}\n"
+            formatted_trades += f"Price: {deal['price']:.5f}\n"
+            formatted_trades += f"Profit: {deal['profit']:.2f}\n"
+            formatted_trades += f"Commission: {deal['commission']:.2f}\n"
+            formatted_trades += f"Swap: {deal['swap']:.2f}\n"
+            formatted_trades += f"Time: {deal_time}\n"
+            formatted_trades += f"Comment: {deal['comment']}\n"
+            formatted_trades += "-" * 40 + "\n"
+        
+        return formatted_trades
+        
+    except Exception as e:
+        return f"Error getting closed trades: {str(e)}"
+
+@tool
+def get_trade_statistics(days_back: int = 30) -> str:
+    """
+    Get trading statistics and analysis
+    
+    Args:
+        days_back: Number of days to analyze (default: 30)
+    
+    Returns:
+        Trading statistics as formatted string
+    """
+    try:
+        from datetime import datetime, timedelta
+        
+        # Calculate date range
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+        
+        # Get deals
+        deals = mt5.history_deals_get(start_date, end_date)
+        
+        if deals is None or len(deals) == 0:
+            return f"No trades found for statistics in the last {days_back} days."
+        
+        # Convert to DataFrame
+        df = pd.DataFrame(list(deals), columns=deals[0]._asdict().keys())
+        trade_deals = df[df['type'].isin([0, 1])]
+        
+        if len(trade_deals) == 0:
+            return f"No trading deals found for statistics."
+        
+        # Calculate statistics
+        total_trades = len(trade_deals)
+        total_profit = trade_deals['profit'].sum()
+        total_commission = trade_deals['commission'].sum()
+        total_swap = trade_deals['swap'].sum()
+        net_profit = total_profit + total_commission + total_swap
+        
+        winning_trades = trade_deals[trade_deals['profit'] > 0]
+        losing_trades = trade_deals[trade_deals['profit'] < 0]
+        
+        win_rate = (len(winning_trades) / total_trades * 100) if total_trades > 0 else 0
+        avg_win = winning_trades['profit'].mean() if len(winning_trades) > 0 else 0
+        avg_loss = losing_trades['profit'].mean() if len(losing_trades) > 0 else 0
+        
+        stats = f"=== TRADING STATISTICS (Last {days_back} days) ===\n"
+        stats += f"Total Trades: {total_trades}\n"
+        stats += f"Winning Trades: {len(winning_trades)}\n"
+        stats += f"Losing Trades: {len(losing_trades)}\n"
+        stats += f"Win Rate: {win_rate:.1f}%\n"
+        stats += f"Average Win: {avg_win:.2f}\n"
+        stats += f"Average Loss: {avg_loss:.2f}\n"
+        stats += f"Total Profit: {total_profit:.2f}\n"
+        stats += f"Total Commission: {total_commission:.2f}\n"
+        stats += f"Total Swap: {total_swap:.2f}\n"
+        stats += f"Net Profit: {net_profit:.2f}\n"
+        
+        # Most traded symbols
+        symbol_counts = trade_deals['symbol'].value_counts()
+        stats += f"\nMost Traded Symbols:\n"
+        for symbol, count in symbol_counts.head(5).items():
+            stats += f"  {symbol}: {count} trades\n"
+        
+        return stats
+        
+    except Exception as e:
+        return f"Error calculating statistics: {str(e)}"
+
+@tool
+def disconnect_mt5() -> str:
+    """
+    Disconnect from MetaTrader 5
+    
+    Returns:
+        Disconnection status message
+    """
+    try:
+        mt5.shutdown()
+        return "Successfully disconnected from MT5"
+    except Exception as e:
+        return f"Error disconnecting from MT5: {str(e)}"
+
+# Initialize the agent with Hugging Face model
+def create_agent():
+    """Create and return the SmolagentsAI agent with MT5 tools"""
+    try:
+        # Use a free model from Hugging Face
+        model = HfApiModel("microsoft/DialoGPT-medium")
+        
+        # Create agent with MetaTrader tools
+        agent = CodeAgent(
+            tools=[
+                connect_mt5, 
+                get_account_info, 
+                get_closed_trades, 
+                get_trade_statistics, 
+                disconnect_mt5
+            ],
+            model=model,
+            max_steps=10
+        )
+        
+        return agent
+    except Exception as e:
+        return None, f"Error creating agent: {str(e)}"
+
+# Global variables
+agent = None
+is_connected = False
+
+def initialize_agent():
+    """Initialize the agent"""
+    global agent
+    agent, error = create_agent()
+    if agent is None:
+        return f"Failed to initialize agent: {error}"
+    return "Agent initialized successfully!"
+
+def connect_to_mt5(login, password, server):
+    """Connect to MT5 with credentials"""
+    global agent, is_connected
+    
+    if agent is None:
+        return "Please initialize the agent first!"
+    
+    try:
+        login_int = int(login)
+        result = agent.run(f"Connect to MT5 with login {login_int}, password {password}, and server {server}")
+        
+        if "Successfully connected" in result:
+            is_connected = True
+            return result
+        else:
+            is_connected = False
+            return result
+            
+    except ValueError:
+        return "Login must be a valid number"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def chat_with_agent(message, history):
+    """Main chat function for the agent"""
+    global agent, is_connected
+    
+    if agent is None:
+        return history + [("Please initialize the agent first!", "")]
+    
+    if not is_connected:
+        return history + [(message, "Please connect to MT5 first using your credentials in the connection tab.")]
+    
+    try:
+        # Run the agent with the user's message
+        response = agent.run(message)
+        history.append((message, response))
+        return history
+    except Exception as e:
+        error_msg = f"Error processing request: {str(e)}"
+        history.append((message, error_msg))
+        return history
+
+# Create Gradio interface
+def create_gradio_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="MetaTrader 5 AI Agent", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🤖 MetaTrader 5 AI Agent")
+        gr.Markdown("An intelligent agent that can access your MT5 account and provide trading information.")
+        
+        with gr.Tabs():
+            # Setup Tab
+            with gr.TabItem("🔧 Setup"):
+                gr.Markdown("### Initialize Agent")
+                init_btn = gr.Button("Initialize Agent", variant="primary")
+                init_output = gr.Textbox(label="Initialization Status", interactive=False)
+                
+                init_btn.click(
+                    initialize_agent,
+                    outputs=init_output
+                )
+                
+                gr.Markdown("### Connect to MetaTrader 5")
+                with gr.Row():
+                    login_input = gr.Textbox(label="Login", placeholder="Your MT5 login number")
+                    password_input = gr.Textbox(label="Password", type="password", placeholder="Your MT5 password")
+                    server_input = gr.Textbox(label="Server", placeholder="Your MT5 server name")
+                
+                connect_btn = gr.Button("Connect to MT5", variant="primary")
+                connection_output = gr.Textbox(label="Connection Status", interactive=False)
+                
+                connect_btn.click(
+                    connect_to_mt5,
+                    inputs=[login_input, password_input, server_input],
+                    outputs=connection_output
+                )
+            
+            # Chat Tab
+            with gr.TabItem("💬 Chat with Agent"):
+                gr.Markdown("### Ask the Agent About Your Trading Account")
+                gr.Markdown("""
+                **Example prompts you can try:**
+                - "Show me my account information"
+                - "Get my closed trades from the last 30 days"
+                - "What are my trading statistics?"
+                - "Show me trades from the last 7 days"
+                - "Calculate my win rate and profit"
+                """)
+                
+                chatbot = gr.Chatbot(
+                    label="MT5 Agent Chat",
+                    height=400,
+                    show_copy_button=True
+                )
+                
+                msg = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Ask about your account, trades, or statistics...",
+                    lines=2
+                )
+                
+                with gr.Row():
+                    send_btn = gr.Button("Send", variant="primary")
+                    clear_btn = gr.Button("Clear Chat")
+                
+                # Event handlers
+                def send_message(message, history):
+                    return chat_with_agent(message, history), ""
+                
+                def clear_chat():
+                    return []
+                
+                send_btn.click(
+                    send_message,
+                    inputs=[msg, chatbot],
+                    outputs=[chatbot, msg]
+                )
+                
+                msg.submit(
+                    send_message,
+                    inputs=[msg, chatbot],
+                    outputs=[chatbot, msg]
+                )
+                
+                clear_btn.click(
+                    clear_chat,
+                    outputs=chatbot
+                )
+            
+            # Help Tab
+            with gr.TabItem("❓ Help"):
+                gr.Markdown("""
+                ## How to Use This Application
+                
+                ### 1. Setup
+                - First, click "Initialize Agent" in the Setup tab
+                - Enter your MT5 credentials (login, password, server)
+                - Click "Connect to MT5"
+                
+                ### 2. Chat with Agent
+                - Go to the "Chat with Agent" tab
+                - Ask questions about your trading account
+                - The agent can provide account info, closed trades, and statistics
+                
+                ### Sample Questions:
+                - "What's my account balance and equity?"
+                - "Show me all closed trades from last week"
+                - "Calculate my trading performance statistics"
+                - "What symbols do I trade most?"
+                - "What's my win rate?"
+                
+                ### Requirements:
+                - MetaTrader 5 terminal must be installed and running
+                - Valid MT5 account credentials
+                - Internet connection for the AI model
+                
+                ### Troubleshooting:
+                - Make sure MT5 terminal is running before connecting
+                - Check your credentials are correct
+                - Ensure your MT5 account allows API access
+                - Try reinitializing the agent if you encounter errors
+                """)
+        
+        # Footer
+        gr.Markdown("---")
+        gr.Markdown("*Powered by SmolagentsAI and MetaTrader 5 API*")
+    
+    return demo
+
+# Launch the application
+if __name__ == "__main__":
+    # Create and launch the Gradio interface
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,  # Creates a public link
+        debug=True
+    )