cnhkmcp 2.1.4__py3-none-any.whl → 2.1.6__py3-none-any.whl

cnhkmcp/untracked/back_up/platform_functions.py

@@ -0,0 +1,2886 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+WorldQuant BRAIN MCP Server - Python Version
+A comprehensive Model Context Protocol (MCP) server for WorldQuant BRAIN platform integration.
+"""
+
+# Ensure proper encoding handling for Windows
+import sys
+import os
+
+# Note: We'll handle encoding issues in individual functions rather than
+# overriding system streams to avoid conflicts with MCP server
+
+import json
+import time
+import asyncio
+import logging
+from typing import Dict, List, Optional, Any, Union
+from dataclasses import dataclass, asdict
+from datetime import datetime, timedelta
+import math
+from time import sleep
+
+import requests
+import pandas as pd
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from bs4 import BeautifulSoup
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, Field, EmailStr
+
+from pathlib import Path
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Pydantic models for type safety
+class AuthCredentials(BaseModel):
+    email: EmailStr
+    password: str
+
+class SimulationSettings(BaseModel):
+    instrumentType: str = "EQUITY"
+    region: str = "USA"
+    universe: str = "TOP3000"
+    delay: int = 1
+    decay: float = 0.0
+    neutralization: str = "NONE"
+    truncation: float = 0.0
+    pasteurization: str = "ON"
+    unitHandling: str = "VERIFY"
+    nanHandling: str = "OFF"
+    language: str = "FASTEXPR"
+    visualization: bool = True
+    testPeriod: str = "P0Y0M"
+    selectionHandling: str = "POSITIVE"
+    selectionLimit: int = 1000
+    maxTrade: str = "OFF"
+    componentActivation: str = "IS"
+
+class SimulationData(BaseModel):
+    type: str = "REGULAR"  # "REGULAR" or "SUPER"
+    settings: SimulationSettings
+    regular: Optional[str] = None
+    combo: Optional[str] = None
+    selection: Optional[str] = None
+
+class BrainApiClient:
+    """WorldQuant BRAIN API client with comprehensive functionality."""
+    
+    def __init__(self):
+        self.base_url = "https://api.worldquantbrain.com"
+        self.session = requests.Session()
+        self.auth_credentials = None
+        self.is_authenticating = False
+        
+        # Configure session
+        self.session.timeout = 30
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+    
+    def log(self, message: str, level: str = "INFO"):
+        """Log messages to stderr to avoid MCP protocol interference."""
+        try:
+            # Try to print with original message first
+            print(f"[{level}] {message}", file=sys.stderr)
+        except UnicodeEncodeError:
+            # Fallback: remove problematic characters and try again
+            try:
+                safe_message = message.encode('ascii', 'ignore').decode('ascii')
+                print(f"[{level}] {safe_message}", file=sys.stderr)
+            except Exception:
+                # Final fallback: just print the level and a safe message
+                print(f"[{level}] Log message", file=sys.stderr)
+        except Exception:
+            # Final fallback: just print the level and a safe message
+            print(f"[{level}] Log message", file=sys.stderr)
+    
+    async def authenticate(self, email: str, password: str) -> Dict[str, Any]:
+        """Authenticate with WorldQuant BRAIN platform with biometric support."""
+        self.log("🔐 Starting Authentication process...", "INFO")
+        
+        try:
+            # Store credentials for potential re-authentication
+            self.auth_credentials = {'email': email, 'password': password}
+            
+            # Clear any existing session data
+            self.session.cookies.clear()
+            self.session.auth = None
+            
+            # Create Basic Authentication header (base64 encoded credentials)
+            import base64
+            credentials = f"{email}:{password}"
+            encoded_credentials = base64.b64encode(credentials.encode()).decode()
+            
+            # Send POST request with Basic Authentication header
+            headers = {
+                'Authorization': f'Basic {encoded_credentials}'
+            }
+            
+            response = self.session.post('https://api.worldquantbrain.com/authentication', headers=headers)
+            
+            # Check for successful authentication (status code 201)
+            if response.status_code == 201:
+                self.log("Authentication successful", "SUCCESS")
+                
+                # Check if JWT token was automatically stored by session
+                jwt_token = self.session.cookies.get('t')
+                if jwt_token:
+                    self.log("JWT token automatically stored by session", "SUCCESS")
+                else:
+                    self.log("⚠️ No JWT token found in session", "WARNING")
+                
+                # Return success response
+                return {
+                    'user': {'email': email},
+                    'status': 'authenticated',
+                    'permissions': ['read', 'write'],
+                    'message': 'Authentication successful',
+                    'status_code': response.status_code,
+                    'has_jwt': jwt_token is not None
+                }
+            
+            # Check if biometric authentication is required (401 with persona)
+            elif response.status_code == 401:
+                www_auth = response.headers.get("WWW-Authenticate")
+                location = response.headers.get("Location")
+                
+                if www_auth == "persona" and location:
+                    self.log("🔴 Biometric authentication required", "INFO")
+                    
+                    # Handle biometric authentication
+                    from urllib.parse import urljoin
+                    biometric_url = urljoin(response.url, location)
+                    
+                    return await self._handle_biometric_auth(biometric_url, email)
+                else:
+                    raise Exception("Incorrect email or password")
+            else:
+                raise Exception(f"Authentication failed with status code: {response.status_code}")
+                    
+        except requests.HTTPError as e:
+            self.log(f"❌ HTTP error during authentication: {e}", "ERROR")
+            raise
+        except Exception as e:
+            self.log(f"❌ Authentication failed: {str(e)}", "ERROR")
+            raise
+    
+    async def _handle_biometric_auth(self, biometric_url: str, email: str) -> Dict[str, Any]:
+        """Handle biometric authentication using browser automation."""
+        self.log("🌐 Starting biometric authentication...", "INFO")
+        
+        try:
+            # Import selenium for browser automation
+            from selenium import webdriver
+            from selenium.webdriver.chrome.options import Options
+            import time
+            
+            # Setup Chrome options
+            options = Options()
+            options.add_argument('--no-sandbox')
+            options.add_argument('--disable-dev-shm-usage')
+            
+            driver = None
+            try:
+                # Open browser with timeout
+                driver = webdriver.Chrome(options=options)
+                # Set a short timeout so it doesn't wait forever
+                driver.set_page_load_timeout(80)  # Only wait 5 seconds
+                
+                self.log("🌐 Opening browser for biometric authentication...", "INFO")
+                
+                # Try to open the URL but handle timeout
+                try:
+                    driver.get(biometric_url)
+                    self.log("Browser page loaded successfully", "SUCCESS")
+                except Exception as timeout_error:
+                    self.log(f"⚠️ Page load timeout (expected): {str(timeout_error)[:50]}...", "WARNING")
+                    self.log("Browser window is open for biometric authentication", "INFO")
+                
+                # Print instructions
+                print("\n" + "="*60, file=sys.stderr)
+                print("BIOMETRIC AUTHENTICATION REQUIRED", file=sys.stderr)
+                print("="*60, file=sys.stderr)
+                print("Browser window is open with biometric authentication page", file=sys.stderr)
+                print("Complete the biometric authentication in the browser", file=sys.stderr)
+                print("The system will automatically check when you're done...", file=sys.stderr)
+                print("="*60, file=sys.stderr)
+                
+                # Keep checking until authentication is complete
+                max_attempts = 60  # 5 minutes maximum (60 * 5 seconds)
+                attempt = 0
+                
+                while attempt < max_attempts:
+                    time.sleep(5)  # Check every 5 seconds
+                    attempt += 1
+                    
+                    # Check if authentication completed
+                    check_response = self.session.post(biometric_url)
+                    self.log(f"🔄 Checking authentication status (attempt {attempt}/{max_attempts}): {check_response.status_code}", "INFO")
+                    
+                    if check_response.status_code == 201:
+                        self.log("Biometric authentication successful!", "SUCCESS")
+                        
+                        # Close browser
+                        driver.quit()
+                        
+                        # Check JWT token
+                        jwt_token = self.session.cookies.get('t')
+                        if jwt_token:
+                            self.log("JWT token received", "SUCCESS")
+                        
+                        # Return success response
+                        return {
+                            'user': {'email': email},
+                            'status': 'authenticated',
+                            'permissions': ['read', 'write'],
+                            'message': 'Biometric authentication successful',
+                            'status_code': check_response.status_code,
+                            'has_jwt': jwt_token is not None
+                        }
+                
+                # If we get here, authentication timed out
+                if driver:
+                    driver.quit()
+                raise Exception("Biometric authentication timed out")
+                
+            except Exception as driver_error:
+                if driver:
+                    try:
+                        driver.quit()
+                    except:
+                        pass
+                raise Exception(f"Browser automation error: {driver_error}")
+                
+        except Exception as e:
+            self.log(f"❌ Biometric authentication failed: {str(e)}", "ERROR")
+            raise
+    
+    async def is_authenticated(self) -> bool:
+        """Check if currently authenticated using JWT token."""
+        try:
+            # Check if we have a JWT token in cookies
+            jwt_token = self.session.cookies.get('t')
+            if not jwt_token:
+                self.log("❌ No JWT token found", "INFO")
+                return False
+            
+            # Test authentication with a simple API call
+            response = self.session.get(f"{self.base_url}/authentication")
+            if response.status_code == 200:
+                return True
+            elif response.status_code == 401:
+                self.log("❌ JWT token expired or invalid (401)", "INFO")
+                return False
+            else:
+                self.log(f"⚠️ Unexpected status code during auth check: {response.status_code}", "WARNING")
+                return False
+        except Exception as e:
+            self.log(f"❌ Error checking authentication: {str(e)}", "ERROR")
+            return False
+    
+    async def ensure_authenticated(self):
+        """Ensure authentication is valid, re-authenticate if needed."""
+        if not await self.is_authenticated() and self.auth_credentials:
+            self.log("🔄 Re-authenticating...", "INFO")
+            await self.authenticate(self.auth_credentials['email'], self.auth_credentials['password'])
+        elif not self.auth_credentials:
+            raise Exception("Not authenticated and no stored credentials available. Please call authenticate() first.")
+    
+    async def get_authentication_status(self) -> Optional[Dict[str, Any]]:
+        """Get current authentication status and user info."""
+        try:
+            response = self.session.get(f"{self.base_url}/users/self")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get auth status: {str(e)}", "ERROR")
+            return None
+    
+    async def create_simulation(self, simulation_data: SimulationData) -> Dict[str, str]:
+        """Create a new simulation on BRAIN platform."""
+        await self.ensure_authenticated()
+        
+        try:
+            self.log("🚀 Creating simulation...", "INFO")
+            
+            # Prepare settings based on simulation type
+            settings_dict = simulation_data.settings.dict()
+            
+            # Remove fields based on simulation type
+            if simulation_data.type == "REGULAR":
+                # Remove SUPER-specific fields for REGULAR
+                settings_dict.pop('selectionHandling', None)
+                settings_dict.pop('selectionLimit', None)
+                settings_dict.pop('componentActivation', None)
+            elif simulation_data.type == "SUPER":
+                # SUPER type keeps all fields
+                pass
+            
+            # Filter out None values from settings
+            settings_dict = {k: v for k, v in settings_dict.items() if v is not None}
+            
+            # Prepare simulation payload
+            payload = {
+                'type': simulation_data.type,
+                'settings': settings_dict
+            }
+            
+            # Add type-specific fields
+            if simulation_data.type == "REGULAR":
+                if simulation_data.regular:
+                    payload['regular'] = simulation_data.regular
+            elif simulation_data.type == "SUPER":
+                if simulation_data.combo:
+                    payload['combo'] = simulation_data.combo
+                if simulation_data.selection:
+                    payload['selection'] = simulation_data.selection
+            
+            # Filter out None values from entire payload
+            payload = {k: v for k, v in payload.items() if v is not None}
+            
+            # Debug: print payload for troubleshooting
+            # print("📋 Sending payload:")
+            # print(json.dumps(payload, indent=2))
+            
+            response = self.session.post(f"{self.base_url}/simulations", json=payload)
+            response.raise_for_status()
+            
+            # Handle empty response body - extract simulation ID from Location header
+            location = response.headers.get('Location', '')
+            simulation_id = location.split('/')[-1] if location else None
+            
+            self.log(f"Simulation created with ID: {simulation_id}", "SUCCESS")
+
+
+            finished = False
+            while True:
+                simulation_progress = self.session.get(location)
+                if simulation_progress.headers.get("Retry-After", 0) == 0:
+                    break
+                print("Sleeping for " + simulation_progress.headers["Retry-After"] + " seconds")
+                sleep(float(simulation_progress.headers["Retry-After"]))
+            print("Alpha done simulating, getting alpha details")
+            alpha_id = simulation_progress.json()["alpha"]
+            alpha = self.session.get("https://api.worldquantbrain.com/alphas/" + alpha_id)
+            result = alpha.json()
+            result['note'] = "if you got a negative alpha sharpe, you can just add a minus sign in front of the last line of the Alpha to flip then think the next step."
+            return result
+            
+        except Exception as e:
+            self.log(f"❌ Failed to create simulation: {str(e)}", "ERROR")
+            raise
+    
+    # get_simulation_status function removed as requested
+    # wait_for_simulation function removed as requested
+    
+    async def get_alpha_details(self, alpha_id: str) -> Dict[str, Any]:
+        """Get detailed information about an alpha."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get alpha details: {str(e)}", "ERROR")
+            raise
+
+    def _is_atom(self, detail: Optional[Dict[str, Any]]) -> bool:
+        """Match atom detection used in extract_regular_alphas.py:
+        - Primary signal: 'classifications' entries containing 'SINGLE_DATA_SET'
+        - Fallbacks: tags list contains 'atom' or classification id/name contains 'ATOM'
+        """
+        if not detail or not isinstance(detail, dict):
+            return False
+
+        classifications = detail.get('classifications') or []
+        for c in classifications:
+            cid = (c.get('id') or c.get('name') or '')
+            if isinstance(cid, str) and 'SINGLE_DATA_SET' in cid:
+                return True
+
+        # Fallbacks
+        tags = detail.get('tags') or []
+        if isinstance(tags, list):
+            for t in tags:
+                if isinstance(t, str) and t.strip().lower() == 'atom':
+                    return True
+
+        for c in classifications:
+            cid = (c.get('id') or c.get('name') or '')
+            if isinstance(cid, str) and 'ATOM' in cid.upper():
+                return True
+
+        return False
+    
+    async def get_datasets(self, instrument_type: str = "EQUITY", region: str = "USA", 
+                          delay: int = 1, universe: str = "TOP3000", theme: str = "false", search: Optional[str] = None) -> Dict[str, Any]:
+        """Get available datasets."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {
+                'instrumentType': instrument_type,
+                'region': region,
+                'delay': delay,
+                'universe': universe,
+                'theme': theme
+            }
+            
+            if search:
+                params['search'] = search
+            
+            response = self.session.get(f"{self.base_url}/data-sets", params=params)
+            response.raise_for_status()
+            response = response.json()
+            response['extraNote'] = "if your returned result is 0, you may want to check your parameter by using get_platform_setting_options tool to got correct parameter"
+            return response
+        except Exception as e:
+            self.log(f"Failed to get datasets: {str(e)}", "ERROR")
+            raise
+    
+    async def get_datafields(self, instrument_type: str = "EQUITY", region: str = "USA",
+                            delay: int = 1, universe: str = "TOP3000", theme: str = "false",
+                            dataset_id: Optional[str] = None, data_type: str = "",
+                            search: Optional[str] = None) -> Dict[str, Any]:
+        """Get available data fields."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {
+                'instrumentType': instrument_type,
+                'region': region,
+                'delay': delay,
+                'universe': universe,
+                'limit': '50',
+                'offset': '0'
+            }
+            
+            if data_type != 'ALL':
+                params['type'] = data_type
+            
+            if dataset_id:
+                params['dataset.id'] = dataset_id
+            if search:
+                params['search'] = search
+            
+            response = self.session.get(f"{self.base_url}/data-fields", params=params)
+            response.raise_for_status()
+            response = response.json()
+            response['extraNote'] = "if your returned result is 0, you may want to check your parameter by using get_platform_setting_options tool to got correct parameter"
+            return response
+        except Exception as e:
+            self.log(f"Failed to get datafields: {str(e)}", "ERROR")
+            raise
+    
+    async def get_alpha_pnl(self, alpha_id: str) -> Dict[str, Any]:
+        """Get PnL data for an alpha with retry logic."""
+        await self.ensure_authenticated()
+        
+        max_retries = 5
+        retry_delay = 2  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get PnL for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/pnl")
+                response.raise_for_status()
+                
+                # Some alphas may return 204 No Content or an empty body
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty PnL response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5  # Exponential backoff
+                        continue
+                    else:
+                        self.log(f"Empty PnL response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    pnl_data = response.json()
+                    if pnl_data:
+                        self.log(f"Successfully retrieved PnL data for alpha {alpha_id}", "SUCCESS")
+                        return pnl_data
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty PnL JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            retry_delay *= 1.5
+                            continue
+                        else:
+                            self.log(f"Empty PnL JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"PnL JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5
+                        continue
+                    else:
+                        self.log(f"PnL JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get alpha PnL for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 1.5
+                    continue
+                else:
+                    self.log(f"Failed to get alpha PnL for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
+    
+    async def get_user_alphas(
+        self,
+        stage: str = "OS",
+        limit: int = 30,
+        offset: int = 0,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+        submission_start_date: Optional[str] = None,
+        submission_end_date: Optional[str] = None,
+        order: Optional[str] = None,
+        hidden: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Get user's alphas with advanced filtering."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {
+                "stage": stage,
+                "limit": limit,
+                "offset": offset,
+            }
+            if start_date:
+                params["dateCreated>"] = start_date
+            if end_date:
+                params["dateCreated<"] = end_date
+            if submission_start_date:
+                params["dateSubmitted>"] = submission_start_date
+            if submission_end_date:
+                params["dateSubmitted<"] = submission_end_date
+            if order:
+                params["order"] = order
+            if hidden is not None:
+                params["hidden"] = str(hidden).lower()
+
+            response = self.session.get(f"{self.base_url}/users/self/alphas", params=params)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get user alphas: {str(e)}", "ERROR")
+            raise
+    
+    async def submit_alpha(self, alpha_id: str) -> bool:
+        """Submit an alpha for production."""
+        await self.ensure_authenticated()
+        
+        try:
+            self.log(f"📤 Submitting alpha {alpha_id} for production...", "INFO")
+            
+            response = self.session.post(f"{self.base_url}/alphas/{alpha_id}/submit")
+            response.raise_for_status()
+            
+            self.log(f"Alpha {alpha_id} submitted successfully", "SUCCESS")
+            return response.__dict__
+            
+        except Exception as e:
+            self.log(f"❌ Failed to submit alpha: {str(e)}", "ERROR")
+            return False
+    
+    async def get_events(self) -> Dict[str, Any]:
+        """Get available events and competitions."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/events")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get events: {str(e)}", "ERROR")
+            raise
+    
+    async def get_leaderboard(self, user_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get leaderboard data."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {}
+            
+            if user_id:
+                params['user'] = user_id
+            else:
+                # Get current user ID if not specified
+                user_response = self.session.get(f"{self.base_url}/users/self")
+                if user_response.status_code == 200:
+                    user_data = user_response.json()
+                    params['user'] = user_data.get('id')
+            
+            response = self.session.get(f"{self.base_url}/consultant/boards/leader", params=params)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get leaderboard: {str(e)}", "ERROR")
+            raise
+
+    async def get_operators(self) -> Dict[str, Any]:
+        """Get available operators for alpha creation."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/operators")
+            response.raise_for_status()
+            operators_data = response.json()
+            
+            # Ensure we return a dictionary format even if API returns a list
+            if isinstance(operators_data, list):
+                return {"operators": operators_data, "count": len(operators_data)}
+            else:
+                return operators_data
+        except Exception as e:
+            self.log(f"Failed to get operators: {str(e)}", "ERROR")
+            raise
+
+    async def run_selection(
+        self,
+        selection: str,
+        instrument_type: str = "EQUITY",
+        region: str = "USA",
+        delay: int = 1,
+        selection_limit: int = 1000,
+        selection_handling: str = "POSITIVE"
+    ) -> Dict[str, Any]:
+        """Run a selection query to filter instruments."""
+        await self.ensure_authenticated()
+        
+        try:
+            selection_data = {
+                "selection": selection,
+                "instrumentType": instrument_type,
+                "region": region,
+                "delay": delay,
+                "selectionLimit": selection_limit,
+                "selectionHandling": selection_handling
+            }
+            
+            response = self.session.get(f"{self.base_url}/simulations/super-selection", params=selection_data)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to run selection: {str(e)}", "ERROR")
+            raise
+
+    async def get_user_profile(self, user_id: str = "self") -> Dict[str, Any]:
+        """Get user profile information."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/users/{user_id}")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get user profile: {str(e)}", "ERROR")
+            raise
+
+    async def get_documentations(self) -> Dict[str, Any]:
+        """Get available documentations and learning materials."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/tutorials")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get documentations: {str(e)}", "ERROR")
+            raise
+
+    # get_messages_summary function removed as requested
+
+    async def get_messages(self, limit: Optional[int] = None, offset: int = 0) -> Dict[str, Any]:
+        """Get messages for the current user with optional pagination.
+
+        Image / large binary payload mitigation:
+          Some messages embed base64 encoded images (e.g. <img src="data:image/png;base64,..."/>).
+          Returning full base64 can explode token usage for an LLM client. We post-process each
+          message description and (by default) extract embedded base64 images to disk and replace
+          them with lightweight placeholders while preserving context.
+
+        Strategies (environment driven in future – currently parameterless public API):
+          - placeholder (default): save images to message_images/ and replace with marker text.
+          - ignore: strip image tags entirely, leaving a note.
+          - keep: leave description unchanged (unsafe for LLM token limits).
+
+        A message dict gains an 'extracted_images' list when images are processed.
+        """
+        await self.ensure_authenticated()
+
+        import re, base64, pathlib
+
+        image_handling = os.environ.get("BRAIN_MESSAGE_IMAGE_MODE", "placeholder").lower()
+        save_dir = pathlib.Path("message_images")
+
+        from typing import Tuple
+        def process_description(desc: str, message_id: str) -> Tuple[str, List[str]]:
+            try:
+                if not desc or image_handling == "keep":
+                    return desc, []
+                attachments: List[str] = []
+                # Regex to capture full <img ...> tag with data URI
+                img_tag_pattern = re.compile(r"<img[^>]+src=\"(data:image/[^\"]+)\"[^>]*>", re.IGNORECASE)
+                # Iterate over unique matches to avoid double work
+                matches = list(img_tag_pattern.finditer(desc))
+                if not matches:
+                    # Additional heuristic: very long base64-looking token inside quotes followed by </img>
+                    # (legacy format noted by user sample). Replace with placeholder.
+                    heuristic_pattern = re.compile(r"([A-Za-z0-9+/]{500,}={0,2})\"\s*</img>")
+                    if image_handling != "keep" and heuristic_pattern.search(desc):
+                        placeholder = "[Embedded image removed - large base64 sequence truncated]"
+                        return heuristic_pattern.sub(placeholder + "</img>", desc), []
+                    return desc, []
+
+                # Ensure save directory exists only if we will store something
+                if image_handling == "placeholder" and not save_dir.exists():
+                    try:
+                        save_dir.mkdir(parents=True, exist_ok=True)
+                    except Exception as e:
+                        self.log(f"Could not create image save directory: {e}", "WARNING")
+
+                new_desc = desc
+                for idx, match in enumerate(matches, start=1):
+                    data_uri = match.group(1)  # data:image/...;base64,XXXX
+                    if not data_uri.lower().startswith("data:image"):
+                        continue
+                    # Split header and base64 payload
+                    if "," not in data_uri:
+                        continue
+                    header, b64_data = data_uri.split(",", 1)
+                    mime_part = header.split(";")[0]  # data:image/png
+                    ext = "png"
+                    if "/" in mime_part:
+                        ext = mime_part.split("/")[1]
+                    safe_ext = (ext or "img").split("?")[0]
+                    placeholder_text = "[Embedded image]"
+                    if image_handling == "ignore":
+                        replacement = f"[Image removed: {safe_ext}]"
+                    elif image_handling == "placeholder":
+                        # Try decode & save
+                        file_name = f"{message_id}_{idx}.{safe_ext}"
+                        file_path = save_dir / file_name
+                        try:
+                            # Guard extremely large strings (>5MB ~ 6.7M base64 chars) to avoid memory blow
+                            if len(b64_data) > 7_000_000:
+                                raise ValueError("Image too large to decode safely")
+                            with open(file_path, "wb") as f:
+                                f.write(base64.b64decode(b64_data))
+                            attachments.append(str(file_path))
+                            replacement = f"[Image extracted -> {file_path}]"
+                        except Exception as e:
+                            self.log(f"Failed to decode embedded image in message {message_id}: {e}", "WARNING")
+                            replacement = "[Image extraction failed - content omitted]"
+                    else:  # keep
+                        replacement = placeholder_text  # shouldn't be used since early return, but safe
+                    # Replace only the matched tag (not global) – use re.sub with count=1 on substring slice
+                    # Safer to operate on new_desc using the exact matched string
+                    original_tag = match.group(0)
+                    new_desc = new_desc.replace(original_tag, replacement, 1)
+                return new_desc, attachments
+            except UnicodeEncodeError as ue:
+                self.log(f"Unicode encoding error in process_description: {ue}", "WARNING")
+                return desc, []
+            except Exception as e:
+                self.log(f"Error in process_description: {e}", "WARNING")
+                return desc, []
+
+        try:
+            params = {}
+            if limit is not None:
+                params['limit'] = limit
+            if offset > 0:
+                params['offset'] = offset
+
+            response = self.session.get(f"{self.base_url}/users/self/messages", params=params)
+            response.raise_for_status()
+            data = response.json()
+
+            # Post-process results for image handling
+            results = data.get('results', [])
+            for msg in results:
+                try:
+                    desc = msg.get('description')
+                    processed_desc, attachments = process_description(desc, msg.get('id', 'msg'))
+                    if attachments or desc != processed_desc:
+                        msg['description'] = processed_desc
+                        if attachments:
+                            msg['extracted_images'] = attachments
+                        else:
+                            # If changed but no attachments (ignore mode) mark sanitized
+                            msg['sanitized'] = True
+                except UnicodeEncodeError as ue:
+                    self.log(f"Unicode encoding error sanitizing message {msg.get('id')}: {ue}", "WARNING")
+                    # Keep original description if encoding fails
+                    continue
+                except Exception as inner_e:
+                    self.log(f"Failed to sanitize message {msg.get('id')}: {inner_e}", "WARNING")
+            data['results'] = results
+            data['image_handling'] = image_handling
+            return data
+        except UnicodeEncodeError as ue:
+            self.log(f"Failed to get messages due to encoding error: {str(ue)}", "ERROR")
+            raise
+        except Exception as e:
+            self.log(f"Failed to get messages: {str(e)}", "ERROR")
+            raise
+
+    async def get_glossary_terms(self, email: str, password: str, headless: bool = False) -> Dict[str, Any]:
+        """Get glossary terms from forum."""
+        try:
+            # Import and use forum functions
+            from forum_functions import forum_client
+            return await forum_client.get_glossary_terms(email, password, headless)
+        except ImportError:
+            self.log("Forum functions not available - install selenium and run forum_functions.py", "WARNING")
+            return {"error": "Forum functions require selenium. Use forum_functions.py directly."}
+        except Exception as e:
+            self.log(f"Glossary extraction failed: {str(e)}", "ERROR")
+            return {"error": str(e)}
+
+    async def search_forum_posts(self, email: str, password: str, search_query: str, 
+                               max_results: int = 50, headless: bool = True) -> Dict[str, Any]:
+        """Search forum posts."""
+        try:
+            # Import and use forum functions
+            from forum_functions import forum_client
+            return await forum_client.search_forum_posts(email, password, search_query, max_results, headless)
+        except ImportError:
+            self.log("Forum functions not available - install selenium and run forum_functions.py", "WARNING")
+            return {"error": "Forum functions require selenium. Use forum_functions.py directly."}
+        except Exception as e:
+            self.log(f"Forum search failed: {str(e)}", "ERROR")
+            return {"error": str(e)}
+
+    async def read_forum_post(self, email: str, password: str, article_id: str, 
+                           headless: bool = False) -> Dict[str, Any]:
+        """Get forum post."""
+        try:
+            # Import and use forum functions
+            from forum_functions import forum_client
+            return await forum_client.read_full_forum_post(email, password, article_id, headless, include_comments=True)
+        except ImportError:
+            self.log("Forum functions not available - install selenium and run forum_functions.py", "WARNING")
+            return {"error": "Forum functions require selenium. Use forum_functions.py directly."}
+        except Exception as e:
+            self.log(f"Forum post retrieval failed: {str(e)}", "ERROR")
+            return {"error": str(e)}
+
+    async def get_alpha_yearly_stats(self, alpha_id: str) -> Dict[str, Any]:
+        """Get yearly statistics for an alpha with retry logic."""
+        await self.ensure_authenticated()
+        
+        max_retries = 5
+        retry_delay = 2  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get yearly stats for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/yearly-stats")
+                response.raise_for_status()
+                
+                # Check if response has content
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty yearly stats response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5  # Exponential backoff
+                        continue
+                    else:
+                        self.log(f"Empty yearly stats response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    yearly_stats = response.json()
+                    if yearly_stats:
+                        self.log(f"Successfully retrieved yearly stats for alpha {alpha_id}", "SUCCESS")
+                        return yearly_stats
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty yearly stats JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            retry_delay *= 1.5
+                            continue
+                        else:
+                            self.log(f"Empty yearly stats JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"Yearly stats JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5
+                        continue
+                    else:
+                        self.log(f"Yearly stats JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get alpha yearly stats for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 1.5
+                    continue
+                else:
+                    self.log(f"Failed to get alpha yearly stats for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
+
+    async def get_production_correlation(self, alpha_id: str) -> Dict[str, Any]:
+        """Get production correlation data for an alpha with retry logic."""
+        await self.ensure_authenticated()
+        
+        max_retries = 5
+        retry_delay = 20  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get production correlation for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/correlations/prod")
+                response.raise_for_status()
+                
+                # Check if response has content
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty production correlation response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Empty production correlation response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    correlation_data = response.json()
+                    if correlation_data:
+                        self.log(f"Successfully retrieved production correlation for alpha {alpha_id}", "SUCCESS")
+                        return correlation_data
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty production correlation JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            continue
+                        else:
+                            self.log(f"Empty production correlation JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"Production correlation JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Production correlation JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get production correlation for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    continue
+                else:
+                    self.log(f"Failed to get production correlation for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
+
+    async def get_self_correlation(self, alpha_id: str) -> Dict[str, Any]:
+        """Get self-correlation data for an alpha with retry logic."""
+        await self.ensure_authenticated()
+        
+        max_retries = 5
+        retry_delay = 20  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get self correlation for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/correlations/self")
+                response.raise_for_status()
+                
+                # Check if response has content
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty self correlation response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Empty self correlation response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    correlation_data = response.json()
+                    if correlation_data:
+                        self.log(f"Successfully retrieved self correlation for alpha {alpha_id}", "SUCCESS")
+                        return correlation_data
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty self correlation JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            continue
+                        else:
+                            self.log(f"Empty self correlation JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"Self correlation JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Self correlation JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get self correlation for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    continue
+                else:
+                    self.log(f"Failed to get self correlation for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
+
+    async def check_correlation(self, alpha_id: str, correlation_type: str = "both", threshold: float = 0.7) -> Dict[str, Any]:
+        """Check alpha correlation against production alphas, self alphas, or both."""
+        await self.ensure_authenticated()
+        
+        try:
+            results = {
+                'alpha_id': alpha_id,
+                'threshold': threshold,
+                'correlation_type': correlation_type,
+                'checks': {}
+            }
+            
+            # Determine which correlations to check
+            check_types = []
+            if correlation_type == "both":
+                check_types = ["production", "self"]
+            else:
+                check_types = [correlation_type]
+            
+            all_passed = True
+            
+            for check_type in check_types:
+                if check_type == "production":
+                    correlation_data = await self.get_production_correlation(alpha_id)
+                elif check_type == "self":
+                    correlation_data = await self.get_self_correlation(alpha_id)
+                else:
+                    continue
+                
+                # Analyze correlation data (robust to schema/records format)
+                if isinstance(correlation_data, dict):
+                    # Prefer strict access to schema.max or top-level max; otherwise error
+                    schema = correlation_data.get('schema') or {}
+                    if isinstance(schema, dict) and 'max' in schema:
+                        max_correlation = float(schema['max'])
+                    elif 'max' in correlation_data:
+                        # Some endpoints place max at top-level
+                        max_correlation = float(correlation_data['max'])
+                    else:
+                        # Attempt to derive from records; if none found, raise error instead of defaulting
+                        records = correlation_data.get('records') or []
+                        if isinstance(records, list) and records:
+                            candidate_max = None
+                            for row in records:
+                                if isinstance(row, (list, tuple)):
+                                    for v in row:
+                                        try:
+                                            vf = float(v)
+                                            if -1.0 <= vf <= 1.0:
+                                                candidate_max = vf if candidate_max is None else max(candidate_max, vf)
+                                        except Exception:
+                                            continue
+                                elif isinstance(row, dict):
+                                    for key in ('correlation', 'prodCorrelation', 'selfCorrelation', 'max'):
+                                        try:
+                                            vf = float(row.get(key))
+                                            if -1.0 <= vf <= 1.0:
+                                                candidate_max = vf if candidate_max is None else max(candidate_max, vf)
+                                        except Exception:
+                                            continue
+                            if candidate_max is None:
+                                raise ValueError("Unable to derive max correlation from records")
+                            max_correlation = float(candidate_max)
+                        else:
+                            raise KeyError("Correlation response missing 'schema.max' or top-level 'max' and no 'records' to derive from")
+                else:
+                    raise TypeError("Correlation data is not a dictionary")
+
+                passes_check = max_correlation < threshold
+                
+                results['checks'][check_type] = {
+                    'max_correlation': max_correlation,
+                    'passes_check': passes_check,
+                    'correlation_data': correlation_data
+                }
+                
+                if not passes_check:
+                    all_passed = False
+            
+            results['all_passed'] = all_passed
+            
+            return results
+            
+        except Exception as e:
+            self.log(f"Failed to check correlation: {str(e)}", "ERROR")
+            raise
+
+    async def get_submission_check(self, alpha_id: str) -> Dict[str, Any]:
+        """Comprehensive pre-submission check."""
+        await self.ensure_authenticated()
+        
+        try:
+            # Get correlation checks using the unified function
+            correlation_checks = await self.check_correlation(alpha_id, correlation_type="both")
+            
+            # Get alpha details for additional validation
+            alpha_details = await self.get_alpha_details(alpha_id)
+            
+            # Compile comprehensive check results
+            checks = {
+                'correlation_checks': correlation_checks,
+                'alpha_details': alpha_details,
+                'all_passed': correlation_checks['all_passed']
+            }
+            
+            return checks
+        except Exception as e:
+            self.log(f"Failed to get submission check: {str(e)}", "ERROR")
+            raise
+
+    async def set_alpha_properties(self, alpha_id: str, name: Optional[str] = None, 
+                                 color: Optional[str] = None, tags: List[str] = None,
+                                 selection_desc: str = "None", combo_desc: str = "None") -> Dict[str, Any]:
+        """Update alpha properties (name, color, tags, descriptions)."""
+        await self.ensure_authenticated()
+        
+        try:
+            data = {}
+            if name:
+                data['name'] = name
+            if color:
+                data['color'] = color
+            if tags:
+                data['tags'] = tags
+            if selection_desc:
+                data['selectionDesc'] = selection_desc
+            if combo_desc:
+                data['comboDesc'] = combo_desc
+            
+            response = self.session.patch(f"{self.base_url}/alphas/{alpha_id}", json=data)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to set alpha properties: {str(e)}", "ERROR")
+            raise
+
+    async def get_record_sets(self, alpha_id: str) -> Dict[str, Any]:
+        """List available record sets for an alpha."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get record sets: {str(e)}", "ERROR")
+            raise
+
+    async def get_record_set_data(self, alpha_id: str, record_set_name: str) -> Dict[str, Any]:
+        """Get data from a specific record set."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/{record_set_name}")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get record set data: {str(e)}", "ERROR")
+            raise
+
+    async def get_user_activities(self, user_id: str, grouping: Optional[str] = None) -> Dict[str, Any]:
+        """Get user activity diversity data."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {}
+            if grouping:
+                params['grouping'] = grouping
+            
+            response = self.session.get(f"{self.base_url}/users/{user_id}/activities", params=params)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get user activities: {str(e)}", "ERROR")
+            raise
+
+    async def get_pyramid_multipliers(self) -> Dict[str, Any]:
+        """Get current pyramid multipliers showing BRAIN's encouragement levels."""
+        await self.ensure_authenticated()
+        
+        try:
+            # Use the correct endpoint without parameters
+            response = self.session.get(f"{self.base_url}/users/self/activities/pyramid-multipliers")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get pyramid multipliers: {str(e)}", "ERROR")
+            raise
+
+    async def value_factor_trendScore(self, start_date: str, end_date: str) -> Dict[str, Any]:
+        """Compute diversity score for regular alphas in a date range.
+
+        Description:
+        This function calculate the diversity of the users' submission, by checking the diversity, we can have a good understanding on the valuefactor's trend.
+        value factor of a user is defiend by This diversity score, which measures three key aspects of work output: the proportion of works
+        with the "Atom" tag (S_A), atom proportion, the breadth of pyramids covered (S_P), and how evenly works
+        are distributed across those pyramids (S_H). Calculated as their product, it rewards
+        strong performance across all three dimensions—encouraging more Atom-tagged works,
+        wider pyramid coverage, and balanced distribution—with weaknesses in any area lowering
+        the total score significantly.
+
+        Inputs (hints for AI callers):
+        - start_date (str): ISO UTC start datetime, e.g. '2025-08-14T00:00:00Z'
+        - end_date (str): ISO UTC end datetime, e.g. '2025-08-18T23:59:59Z'
+        - Note: this tool always uses 'OS' (submission dates) to define the window; callers do not need to supply a stage.
+                - Note: P_max (total number of possible pyramids) is derived from the platform
+                    pyramid-multipliers endpoint and not supplied by callers.
+
+        Returns (compact JSON): {
+            'diversity_score': float,
+            'N': int,  # total regular alphas in window
+            'A': int,  # number of Atom-tagged works (is_single_data_set)
+            'P': int,  # pyramid coverage count in the sample
+            'P_max': int, # used max for normalization
+            'S_A': float, 'S_P': float, 'S_H': float,
+            'per_pyramid_counts': {pyramid_name: count}
+        }
+        """
+        # Fetch user alphas (always use OS / submission dates per product policy)
+        await self.ensure_authenticated()
+        alphas_resp = await self.get_user_alphas(stage='OS', limit=500, submission_start_date=start_date, submission_end_date=end_date)
+
+        if not isinstance(alphas_resp, dict) or 'results' not in alphas_resp:
+            return {'error': 'Unexpected response from get_user_alphas', 'raw': alphas_resp}
+
+        alphas = alphas_resp['results']
+        regular = [a for a in alphas if a.get('type') == 'REGULAR']
+
+        # Fetch details for each regular alpha
+        pyramid_list = []
+        atom_count = 0
+        per_pyramid = {}
+        for a in regular:
+            try:
+                detail = await self.get_alpha_details(a.get('id'))
+            except Exception:
+                continue
+
+            is_atom = self._is_atom(detail)
+            if is_atom:
+                atom_count += 1
+
+            # Extract pyramids
+            ps = []
+            if isinstance(detail.get('pyramids'), list):
+                ps = [p.get('name') for p in detail.get('pyramids') if p.get('name')]
+            else:
+                pt = detail.get('pyramidThemes') or {}
+                pss = pt.get('pyramids') if isinstance(pt, dict) else None
+                if pss and isinstance(pss, list):
+                    ps = [p.get('name') for p in pss if p.get('name')]
+
+            for p in ps:
+                pyramid_list.append(p)
+                per_pyramid[p] = per_pyramid.get(p, 0) + 1
+
+        N = len(regular)
+        A = atom_count
+        P = len(per_pyramid)
+
+        # Determine P_max similarly to the script: use pyramid multipliers if available
+        P_max = None
+        try:
+            pm = await self.get_pyramid_multipliers()
+            if isinstance(pm, dict) and 'pyramids' in pm:
+                pyramids_list = pm.get('pyramids') or []
+                P_max = len(pyramids_list)
+        except Exception:
+            P_max = None
+
+        if not P_max or P_max <= 0:
+            P_max = max(P, 1)
+
+        # Component scores
+        S_A = (A / N) if N > 0 else 0.0
+        S_P = (P / P_max) if P_max > 0 else 0.0
+
+        # Entropy
+        S_H = 0.0
+        if P <= 1 or not per_pyramid:
+            S_H = 0.0
+        else:
+            total_occ = sum(per_pyramid.values())
+            H = 0.0
+            for cnt in per_pyramid.values():
+                q = cnt / total_occ if total_occ > 0 else 0
+                if q > 0:
+                    H -= q * math.log2(q)
+            max_H = math.log2(P) if P > 0 else 1
+            S_H = (H / max_H) if max_H > 0 else 0.0
+
+        diversity_score = S_A * S_P * S_H
+
+        return {
+            'diversity_score': diversity_score,
+            'N': N,
+            'A': A,
+            'P': P,
+            'P_max': P_max,
+            'S_A': S_A,
+            'S_P': S_P,
+            'S_H': S_H,
+            'per_pyramid_counts': per_pyramid
+        }
+
+    async def get_pyramid_alphas(self, start_date: Optional[str] = None,
+                               end_date: Optional[str] = None) -> Dict[str, Any]:
+        """Get user's current alpha distribution across pyramid categories."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {}
+            if start_date:
+                params['startDate'] = start_date
+            if end_date:
+                params['endDate'] = end_date
+            
+            # Try the user-specific activities endpoint first (like pyramid-multipliers)
+            response = self.session.get(f"{self.base_url}/users/self/activities/pyramid-alphas", params=params)
+            
+            # If that fails, try alternative endpoints
+            if response.status_code == 404:
+                # Try alternative endpoint structure
+                response = self.session.get(f"{self.base_url}/users/self/pyramid/alphas", params=params)
+                
+                if response.status_code == 404:
+                    # Try yet another alternative
+                    response = self.session.get(f"{self.base_url}/activities/pyramid-alphas", params=params)
+                    
+                    if response.status_code == 404:
+                        # Return an informative error with what we tried
+                        return {
+                            "error": "Pyramid alphas endpoint not found",
+                            "tried_endpoints": [
+                                "/users/self/activities/pyramid-alphas",
+                                "/users/self/pyramid/alphas", 
+                                "/activities/pyramid-alphas",
+                                "/pyramid/alphas"
+                            ],
+                            "suggestion": "This endpoint may not be available in the current API version"
+                        }
+            
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get pyramid alphas: {str(e)}", "ERROR")
+            raise
+
+    async def get_user_competitions(self, user_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get list of competitions that the user is participating in."""
+        await self.ensure_authenticated()
+        
+        try:
+            if not user_id:
+                # Get current user ID if not specified
+                user_response = self.session.get(f"{self.base_url}/users/self")
+                if user_response.status_code == 200:
+                    user_data = user_response.json()
+                    user_id = user_data.get('id')
+                else:
+                    user_id = 'self'
+            
+            response = self.session.get(f"{self.base_url}/users/{user_id}/competitions")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get user competitions: {str(e)}", "ERROR")
+            raise
+
+    async def get_competition_details(self, competition_id: str) -> Dict[str, Any]:
+        """Get detailed information about a specific competition."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/competitions/{competition_id}")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get competition details: {str(e)}", "ERROR")
+            raise
+
+    async def get_competition_agreement(self, competition_id: str) -> Dict[str, Any]:
+        """Get the rules, terms, and agreement for a specific competition."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/competitions/{competition_id}/agreement")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get competition agreement: {str(e)}", "ERROR")
+            raise
+
+    async def get_platform_setting_options(self) -> Dict[str, Any]:
+        """Get available instrument types, regions, delays, and universes."""
+        await self.ensure_authenticated()
+        
+        try:
+            # Use OPTIONS method on simulations endpoint to get configuration options
+            response = self.session.options(f"{self.base_url}/simulations")
+            response.raise_for_status()
+            
+            # Parse the settings structure from the response
+            settings_data = response.json()
+            settings_options = settings_data['actions']['POST']['settings']['children']
+            
+            # Extract instrument configuration options
+            instrument_type_data = {}
+            region_data = {}
+            universe_data = {}
+            delay_data = {}
+            neutralization_data = {}
+            
+            # Parse each setting type
+            for key, setting in settings_options.items():
+                if setting['type'] == 'choice':
+                    if setting['label'] == 'Instrument type':
+                        instrument_type_data = setting['choices']
+                    elif setting['label'] == 'Region':
+                        region_data = setting['choices']['instrumentType']
+                    elif setting['label'] == 'Universe':
+                        universe_data = setting['choices']['instrumentType']
+                    elif setting['label'] == 'Delay':
+                        delay_data = setting['choices']['instrumentType']
+                    elif setting['label'] == 'Neutralization':
+                        neutralization_data = setting['choices']['instrumentType']
+            
+            # Build comprehensive instrument options
+            data_list = []
+            
+            for instrument_type in instrument_type_data:
+                for region in region_data[instrument_type['value']]:
+                    for delay in delay_data[instrument_type['value']]['region'][region['value']]:
+                        row = {
+                            'InstrumentType': instrument_type['value'],
+                            'Region': region['value'],
+                            'Delay': delay['value']
+                        }
+                        row['Universe'] = [
+                            item['value'] for item in universe_data[instrument_type['value']]['region'][region['value']]
+                        ]
+                        row['Neutralization'] = [
+                            item['value'] for item in neutralization_data[instrument_type['value']]['region'][region['value']]
+                        ]
+                        data_list.append(row)
+            
+            # Return structured data
+            return {
+                'instrument_options': data_list,
+                'total_combinations': len(data_list),
+                'instrument_types': [item['value'] for item in instrument_type_data],
+                'regions_by_type': {
+                    item['value']: [r['value'] for r in region_data[item['value']]]
+                    for item in instrument_type_data
+                }
+            }
+            
+        except Exception as e:
+            self.log(f"Failed to get instrument options: {str(e)}", "ERROR")
+            raise
+
+    async def performance_comparison(self, alpha_id: str, team_id: Optional[str] = None, 
+                                   competition: Optional[str] = None) -> Dict[str, Any]:
+        """Get performance comparison data for an alpha."""
+        await self.ensure_authenticated()
+        
+        try:
+            params = {}
+            if team_id:
+                params['team_id'] = team_id
+            if competition:
+                params['competition'] = competition
+            
+            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/performance-comparison", params=params)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get performance comparison: {str(e)}", "ERROR")
+            raise
+
+    # combine_test_results function removed as requested
+
+    async def expand_nested_data(self, data: List[Dict[str, Any]], preserve_original: bool = True) -> List[Dict[str, Any]]:
+        """Flatten complex nested data structures into tabular format."""
+        try:
+            expanded_data = []
+            
+            for item in data:
+                expanded_item = {}
+                
+                for key, value in item.items():
+                    if isinstance(value, dict):
+                        # Expand nested dictionary
+                        for nested_key, nested_value in value.items():
+                            expanded_key = f"{key}_{nested_key}"
+                            expanded_item[expanded_key] = nested_value
+                        
+                        # Preserve original if requested
+                        if preserve_original:
+                            expanded_item[key] = value
+                    elif isinstance(value, list):
+                        # Handle list values
+                        expanded_item[key] = str(value) if value else []
+                        
+                        # Preserve original if requested
+                        if preserve_original:
+                            expanded_item[key] = value
+                    else:
+                        # Simple value
+                        expanded_item[key] = value
+                
+                expanded_data.append(expanded_item)
+            
+            return expanded_data
+        except Exception as e:
+            self.log(f"Failed to expand nested data: {str(e)}", "ERROR")
+            raise
+
+    # generate_alpha_links function removed as requested
+
+    async def read_specific_documentation(self, page_id: str) -> Dict[str, Any]:
+        """Retrieve detailed content of a specific documentation page/article."""
+        await self.ensure_authenticated()
+        
+        try:
+            response = self.session.get(f"{self.base_url}/tutorial-pages/{page_id}")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            self.log(f"Failed to get documentation page: {str(e)}", "ERROR")
+            raise
+
+    # Badge status function removed as requested
+
+# Initialize MCP server
+mcp = FastMCP('brain_mcp_server')
+
+# Initialize API client
+brain_client = BrainApiClient()
+
+# Configuration management
+CONFIG_FILE = "user_config.json"
+
+def _resolve_config_path(for_write: bool = False) -> str:
+    """
+    Resolve the config file path with this priority:
+    1) BRAIN_CONFIG_PATH (file or directory)
+    2) Directory of running script when available, else current working directory
+    3) Current working directory
+
+    When for_write=True, returns the preferred path even if it doesn't exist yet.
+    """
+    # 1) Explicit override via env var
+    env_path = os.environ.get("BRAIN_CONFIG_PATH")
+    if env_path:
+        p = Path(env_path).expanduser()
+        target = p / CONFIG_FILE if p.is_dir() else p
+        # For read, only if it exists; for write, allow regardless
+        if for_write or target.exists():
+            return str(target.resolve())
+
+    # 2) Script/module directory when available, else CWD (works in notebooks)
+    base_dir = Path.cwd()
+    try:
+        # __file__ is not defined in notebooks; this will fail there and keep CWD
+        script_dir = Path(__file__).resolve().parent  # type: ignore[name-defined]
+        base_dir = script_dir
+    except Exception:
+        # Fall back to current working directory for notebooks/REPL
+        pass
+
+    module_path = base_dir / CONFIG_FILE
+    if not for_write and module_path.exists():
+        return str(module_path.resolve())
+
+    # 3) Fallback to CWD for backward compatibility
+    cwd_path = Path.cwd() / CONFIG_FILE
+    if not for_write and cwd_path.exists():
+        return str(cwd_path.resolve())
+
+    # For writes (or when nothing exists), prefer the module/base directory
+    return str(module_path.resolve())
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from file with robust path resolution.
+
+    Looks for the config in this order: BRAIN_CONFIG_PATH -> module directory -> CWD.
+    Returns an empty dict when not found or on error.
+    """
+    path = _resolve_config_path(for_write=False)
+    if os.path.exists(path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            logger.error(f"Failed to load config from '{path}': {e}")
+    return {}
+
+
+def save_config(config: Dict[str, Any]):
+    """Save configuration to file using the resolved config path.
+
+    Uses BRAIN_CONFIG_PATH if set; otherwise writes next to this module.
+    Ensures the target directory exists.
+    """
+    try:
+        path = _resolve_config_path(for_write=True)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+    except Exception as e:
+        logger.error(f"Failed to save config: {e}")
+
+# MCP Tools
+
+@mcp.tool()
+async def authenticate(email: Optional[str] = "", password: Optional[str] = "") -> Dict[str, Any]:
+    """
+    🔐 Authenticate with WorldQuant BRAIN platform.
+    
+    This is the first step in any BRAIN workflow. You must authenticate before using any other tools.
+    
+    Args:
+        email: Your BRAIN platform email address (optional if in config or .brain_credentials)
+        password: Your BRAIN platform password (optional if in config or .brain_credentials)
+    
+    Returns:
+        Authentication result with user info and permissions
+    """
+    try:
+        config = load_config()
+        if 'credentials' in config:
+            if not email:
+                email = config['credentials'].get('email', '')
+            if not password:
+                password = config['credentials'].get('password', '')
+        
+        if not email or not password:
+            return {"error": "Email and password required. Either provide them as arguments, configure them in user_config.json, or create a .brain_credentials file in your home directory with format: [\"email\", \"password\"]"}
+        
+        result = await brain_client.authenticate(email, password)
+        
+        # Save credentials to config for future use
+        config = load_config()
+        if 'credentials' not in config:
+            config['credentials'] = {}
+        config['credentials']['email'] = email
+        config['credentials']['password'] = password
+        save_config(config)
+        
+        return result
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@mcp.tool()
+async def value_factor_trendScore(start_date: str, end_date: str) -> Dict[str, Any]:
+    """Compute and return the diversity score for REGULAR alphas in a submission-date window.
+    This function calculate the diversity of the users' submission, by checking the diversity, we can have a good understanding on the valuefactor's trend.
+    This MCP tool wraps BrainApiClient.value_factor_trendScore and always uses submission dates (OS).
+
+    Inputs:
+        - start_date: ISO UTC start datetime (e.g. '2025-08-14T00:00:00Z')
+        - end_date: ISO UTC end datetime (e.g. '2025-08-18T23:59:59Z')
+        - p_max: optional integer total number of pyramid categories for normalization
+
+    Returns: compact JSON with diversity_score, N, A, P, P_max, S_A, S_P, S_H, per_pyramid_counts
+    """
+    try:
+        return await brain_client.value_factor_trendScore(start_date=start_date, end_date=end_date)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def manage_config(action: str = "get", settings: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    🔧 Manage configuration settings - get or update configuration.
+    
+    Args:
+        action: Action to perform ("get" to retrieve config, "set" to update config)
+        settings: Configuration settings to update (required when action="set")
+    
+    Returns:
+        Current or updated configuration including authentication status
+    """
+    if action == "get":
+        config = load_config()
+        auth_status = await brain_client.get_authentication_status()
+        
+        return {
+            "config": config,
+            "auth_status": auth_status,
+            "is_authenticated": await brain_client.is_authenticated()
+        }
+    
+    elif action == "set":
+        if settings is None:
+            return {"error": "Settings parameter is required when action='set'"}
+        
+        config = load_config()
+        config.update(settings)
+        save_config(config)
+        return config
+    
+    else:
+        return {"error": f"Invalid action '{action}'. Use 'get' or 'set'."}
+
+@mcp.tool()
+async def create_simulation(
+    type: str = "REGULAR",
+    instrument_type: str = "EQUITY",
+    region: str = "USA",
+    universe: str = "TOP3000",
+    delay: int = 1,
+    decay: float = 0.0,
+    neutralization: str = "NONE",
+    truncation: float = 0.0,
+    test_period: str = "P0Y0M",
+    unit_handling: str = "VERIFY",
+    nan_handling: str = "OFF",
+    language: str = "FASTEXPR",
+    visualization: bool = True,
+    regular: Optional[str] = None,
+    combo: Optional[str] = None,
+    selection: Optional[str] = None,
+    pasteurization: str = "ON",
+    max_trade: str = "OFF",
+    selection_handling: str = "POSITIVE",
+    selection_limit: int = 1000,
+    component_activation: str = "IS"
+) -> Dict[str, Any]:
+    """
+    🚀 Create a new simulation on BRAIN platform.
+    
+    This tool creates and starts a simulation with your alpha code. Use this after you have your alpha formula ready.
+    
+    Args:
+        type: Simulation type ("REGULAR" or "SUPER")
+        instrument_type: Type of instruments (e.g., "EQUITY")
+        region: Market region (e.g., "USA")
+        universe: Universe of stocks (e.g., "TOP3000")
+        delay: Data delay (0 or 1)
+        decay: Decay value for the simulation
+        neutralization: Neutralization method
+        truncation: Truncation value
+        test_period: Test period (e.g., "P0Y0M" for 1 year 6 months)
+        unit_handling: Unit handling method
+        nan_handling: NaN handling method
+        language: Expression language (e.g., "FASTEXPR")
+        visualization: Enable visualization
+        regular: Regular simulation code (for REGULAR type)
+        combo: Combo code (for SUPER type)
+        selection: Selection code (for SUPER type)
+    
+    Returns:
+        Simulation creation result with ID and location
+    """
+    try:
+        settings = SimulationSettings(
+            instrumentType=instrument_type,
+            region=region,
+            universe=universe,
+            delay=delay,
+            decay=decay,
+            neutralization=neutralization,
+            truncation=truncation,
+            testPeriod=test_period,
+            unitHandling=unit_handling,
+            nanHandling=nan_handling,
+            language=language,
+            visualization=visualization
+        )
+        
+        simulation_data = SimulationData(
+            type=type,
+            settings=settings,
+            regular=regular,
+            combo=combo,
+            selection=selection
+        )
+        
+        result = await brain_client.create_simulation(simulation_data)
+        return result
+    except Exception as e:
+        return {"error": str(e), "note":", you need to call three mcp tools get_operators, get_platform_setting_options and get_datafields to check whether you correctly use the operators, setting the simulation settings, and existing data fields."}
+
+# get_simulation_status MCP tool removed as requested
+# wait_for_simulation MCP tool removed as requested
+
+@mcp.tool()
+async def get_alpha_details(alpha_id: str) -> Dict[str, Any]:
+    """
+    📋 Get detailed information about an alpha.
+    
+    Args:
+        alpha_id: The ID of the alpha to retrieve
+    
+    Returns:
+        Detailed alpha information
+    """
+    try:
+        return await brain_client.get_alpha_details(alpha_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_datasets(
+    instrument_type: str = "EQUITY",
+    region: str = "USA",
+    delay: int = 1,
+    universe: str = "TOP3000",
+    theme: str = "false",
+    search: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    📚 Get available datasets for research.
+    
+    Use this to discover what data is available for your alpha research.
+    
+    Args:
+        instrument_type: Type of instruments (e.g., "EQUITY")
+        region: Market region (e.g., "USA")
+        delay: Data delay (0 or 1)
+        universe: Universe of stocks (e.g., "TOP3000")
+        theme: Theme filter
+    
+    Returns:
+        Available datasets
+    """
+    try:
+        return await brain_client.get_datasets(instrument_type, region, delay, universe, theme,search)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_datafields(
+    instrument_type: str = "EQUITY",
+    region: str = "USA",
+    delay: int = 1,
+    universe: str = "TOP3000",
+    theme: str = "false",
+    dataset_id: Optional[str] = None,
+    data_type: str = "",
+    search: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    🔍 Get available data fields for alpha construction.
+    
+    Use this to find specific data fields you can use in your alpha formulas.
+    
+    Args:
+        instrument_type: Type of instruments (e.g., "EQUITY")
+        region: Market region (e.g., "USA")
+        delay: Data delay (0 or 1)
+        universe: Universe of stocks (e.g., "TOP3000")
+        theme: Theme filter
+        dataset_id: Specific dataset ID to filter by
+        data_type: Type of data (e.g., "MATRIX")
+        search: Search term to filter fields
+    
+    Returns:
+        Available data fields
+    """
+    try:
+        return await brain_client.get_datafields(
+            instrument_type, region, delay, universe, theme, 
+            dataset_id, data_type, search
+        )
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_alpha_pnl(alpha_id: str) -> Dict[str, Any]:
+    """
+    📈 Get PnL (Profit and Loss) data for an alpha.
+    
+    Args:
+        alpha_id: The ID of the alpha
+    
+    Returns:
+        PnL data for the alpha
+    """
+    try:
+        return await brain_client.get_alpha_pnl(alpha_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_user_alphas(
+    stage: str = "IS",
+    limit: int = 30,
+    offset: int = 0,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    submission_start_date: Optional[str] = None,
+    submission_end_date: Optional[str] = None,
+    order: Optional[str] = None,
+    hidden: Optional[bool] = None,
+) -> Dict[str, Any]:
+    """
+    👤 Get user's alphas with advanced filtering, pagination, and sorting.
+
+    This tool retrieves a list of your alphas, allowing for detailed filtering based on stage,
+    creation date, submission date, and visibility. It also supports pagination and custom sorting.
+
+    Args:
+        stage (str): The stage of the alphas to retrieve.
+            - "IS": In-Sample (alphas that have not been submitted).
+            - "OS": Out-of-Sample (alphas that have been submitted).
+            Defaults to "IS".
+        limit (int): The maximum number of alphas to return in a single request.
+            For example, `limit=50` will return at most 50 alphas. Defaults to 30.
+        offset (int): The number of alphas to skip from the beginning of the list.
+            Used for pagination. For example, `limit=50, offset=50` will retrieve alphas 51-100.
+            Defaults to 0.
+        start_date (Optional[str]): The earliest creation date for the alphas to be included.
+            Filters for alphas created on or after this date.
+            Example format: "2023-01-01T00:00:00Z".
+        end_date (Optional[str]): The latest creation date for the alphas to be included.
+            Filters for alphas created before this date.
+            Example format: "2023-12-31T23:59:59Z".
+        submission_start_date (Optional[str]): The earliest submission date for the alphas.
+            Only applies to "OS" alphas. Filters for alphas submitted on or after this date.
+            Example format: "2024-01-01T00:00:00Z".
+        submission_end_date (Optional[str]): The latest submission date for the alphas.
+            Only applies to "OS" alphas. Filters for alphas submitted before this date.
+            Example format: "2024-06-30T23:59:59Z".
+        order (Optional[str]): The sorting order for the returned alphas.
+            Prefix with a hyphen (-) for descending order.
+            Examples: "name" (sort by name ascending), "-dateSubmitted" (sort by submission date descending).
+        hidden (Optional[bool]): Filter alphas based on their visibility.
+            - `True`: Only return hidden alphas.
+            - `False`: Only return non-hidden alphas.
+            If not provided, both hidden and non-hidden alphas are returned.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing a list of alpha details under the 'results' key,
+        along with pagination information. If an error occurs, it returns a dictionary with an 'error' key.
+    """
+    try:
+        return await brain_client.get_user_alphas(
+            stage=stage,
+            limit=limit,
+            offset=offset,
+            start_date=start_date,
+            end_date=end_date,
+            submission_start_date=submission_start_date,
+            submission_end_date=submission_end_date,
+            order=order,
+            hidden=hidden,
+        )
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def submit_alpha(alpha_id: str) -> Dict[str, Any]:
+    """
+    📤 Submit an alpha for production.
+    
+    Use this when your alpha is ready for production deployment.
+    
+    Args:
+        alpha_id: The ID of the alpha to submit
+    
+    Returns:
+        Submission result
+    """
+    try:
+        success = await brain_client.submit_alpha(alpha_id)
+        return {"submit_result": success, "alpha_id": alpha_id}
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_events() -> Dict[str, Any]:
+    """
+    🏆 Get available events and competitions.
+    
+    Returns:
+        Available events and competitions
+    """
+    try:
+        return await brain_client.get_events()
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_leaderboard(user_id: Optional[str] = None) -> Dict[str, Any]:
+    """
+    🏅 Get leaderboard data.
+    
+    Args:
+        user_id: Optional user ID to filter results
+    
+    Returns:
+        Leaderboard data
+    """
+    try:
+        return await brain_client.get_leaderboard(user_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+# batch_process_alphas MCP tool removed as requested
+
+@mcp.tool()
+async def save_simulation_data(simulation_id: str, filename: str) -> Dict[str, Any]:
+    """
+    💾 Save simulation data to a file.
+    
+    Args:
+        simulation_id: The simulation ID
+        filename: Filename to save the data
+    
+    Returns:
+        Save operation result
+    """
+    try:
+        # Get simulation data
+        simulation_data = await brain_client.get_simulation_status(simulation_id)
+        
+        # Save to file
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(simulation_data, f, indent=2)
+        
+        return {"success": True, "filename": filename, "simulation_id": simulation_id}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+
+@mcp.tool()
+async def get_operators() -> Dict[str, Any]:
+    """
+    🔧 Get available operators for alpha creation.
+    
+    Returns:
+        Dictionary containing operators list and count
+    """
+    try:
+        return await brain_client.get_operators()
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def run_selection(
+    selection: str,
+    instrument_type: str = "EQUITY",
+    region: str = "USA",
+    delay: int = 1,
+    selection_limit: int = 1000,
+    selection_handling: str = "POSITIVE"
+) -> Dict[str, Any]:
+    """
+    🎯 Run a selection query to filter instruments.
+    
+    Args:
+        selection: Selection criteria
+        instrument_type: Type of instruments
+        region: Geographic region
+        delay: Delay setting
+        selection_limit: Maximum number of results
+        selection_handling: How to handle selection results
+    
+    Returns:
+        Selection results
+    """
+    try:
+        return await brain_client.run_selection(
+            selection, instrument_type, region, delay, selection_limit, selection_handling
+        )
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_user_profile(user_id: str = "self") -> Dict[str, Any]:
+    """
+    👤 Get user profile information.
+    
+    Args:
+        user_id: User ID (default: "self" for current user)
+    
+    Returns:
+        User profile data
+    """
+    try:
+        return await brain_client.get_user_profile(user_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_documentations() -> Dict[str, Any]:
+    """
+    📚 Get available documentations and learning materials.
+    
+    Returns:
+        List of documentations
+    """
+    try:
+        return await brain_client.get_documentations()
+    except Exception as e:
+        return {"error": str(e)}
+
+# get_messages_summary MCP tool removed as requested
+
+@mcp.tool()
+async def get_messages(limit: Optional[int] = 0, offset: int = 0) -> Dict[str, Any]:
+    """
+    Get messages for the current user with optional pagination.
+    
+    Args:
+        limit: Maximum number of messages to return (e.g., 10 for top 10 messages)
+               Can be None (no limit), an integer, or a string that can be converted to int
+        offset: Number of messages to skip (for pagination)
+               Can be an integer or a string that can be converted to int
+    
+    Returns:
+        Messages for the current user, optionally limited by count
+    """
+    # Wrap the entire function in a try-catch to handle any encoding issues
+    try:
+        # Enhanced parameter validation and conversion
+        validated_limit = None
+        validated_offset = 0
+        
+        # Validate and convert limit parameter
+        if limit is not None:
+            if isinstance(limit, str):
+                if limit.strip() == "":
+                    # Empty string means no limit
+                    validated_limit = 0
+                else:
+                    try:
+                        validated_limit = int(limit)
+                        if validated_limit < 0:
+                            return {"error": f"Limit must be non-negative, got: {limit}"}
+                    except ValueError:
+                        return {"error": f"Invalid limit value '{limit}'. Must be a number or empty string."}
+            elif isinstance(limit, (int, float)):
+                validated_limit = int(limit)
+                if validated_limit < 0:
+                    return {"error": f"Limit must be non-negative, got: {limit}"}
+            else:
+                return {"error": f"Invalid limit type {type(limit).__name__}. Expected int, float, str, or None."}
+        
+        # Validate and convert offset parameter
+        if isinstance(offset, str):
+            try:
+                validated_offset = int(offset)
+            except ValueError:
+                return {"error": f"Invalid offset value '{offset}'. Must be a number."}
+        elif isinstance(offset, (int, float)):
+            validated_offset = int(offset)
+        else:
+            return {"error": f"Invalid offset type {type(offset).__name__}. Expected int, float, or str."}
+        
+        if validated_offset < 0:
+            return {"error": f"Offset must be non-negative, got: {offset}"}
+        
+        # Log the validated parameters for debugging (without emojis to avoid encoding issues)
+        try:
+            print(f"get_messages called with validated parameters: limit={validated_limit}, offset={validated_offset}")
+        except Exception:
+            print(f"get_messages called with parameters: limit={validated_limit}, offset={validated_offset}")
+        
+        # Call the brain client with validated parameters
+        result = await brain_client.get_messages(validated_limit, validated_offset)
+        
+        # Add validation info to the result
+        if isinstance(result, dict) and "error" not in result:
+            result["_validation"] = {
+                "original_limit": limit,
+                "original_offset": offset,
+                "validated_limit": validated_limit,
+                "validated_offset": validated_offset,
+                "parameter_types": {
+                    "limit": str(type(limit)),
+                    "offset": str(type(offset))
+                }
+            }
+        
+        return result
+        
+    except UnicodeEncodeError as ue:
+        # Handle encoding errors specifically
+        error_msg = f"get_messages failed due to encoding error: {str(ue)}"
+        try:
+            print(f"ENCODING ERROR: {error_msg}")
+        except Exception:
+            print(f"get_messages encoding error: {str(ue)}")
+        return {
+            "error": error_msg,
+            "error_type": "UnicodeEncodeError",
+            "original_params": {
+                "limit": limit,
+                "offset": offset,
+                "limit_type": str(type(limit)),
+                "offset_type": str(type(offset))
+            }
+        }
+    except Exception as e:
+        error_msg = f"get_messages failed: {str(e)}"
+        try:
+            print(f"ERROR: {error_msg}")
+        except Exception:
+            print(f"get_messages failed: {str(e)}")
+        return {
+            "error": error_msg,
+            "error_type": type(e).__name__,
+            "original_params": {
+                "limit": limit,
+                "offset": offset,
+                "limit_type": str(type(limit)),
+                "offset_type": str(type(offset))
+            }
+        }
+
+@mcp.tool()
+async def get_glossary_terms(email: str = "", password: str = "", headless: bool = False) -> Dict[str, Any]:
+    """
+    📚 Get glossary terms from WorldQuant BRAIN forum.
+    
+    Note: This requires Selenium and is implemented in forum_functions.py
+    
+    Args:
+        email: Your BRAIN platform email address (optional if in config)
+        password: Your BRAIN platform password (optional if in config)
+        headless: Run browser in headless mode (default: False)
+    
+    Returns:
+        Glossary terms with definitions
+    """
+    try:
+        # Load config to get credentials if not provided
+        config = load_config()
+        
+        # Use provided credentials or fall back to config
+        if not email and 'credentials' in config:
+            email = config['credentials'].get('email', '')
+        if not password and 'credentials' in config:
+            password = config['credentials'].get('password', '')
+        
+        if not email or not password:
+            return {"error": "Email and password required. Either provide them as arguments or configure them in user_config.json"}
+        
+        return await brain_client.get_glossary_terms(email, password, headless)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def search_forum_posts(search_query: str, email: str = "", password: str = "", 
+                           max_results: int = 50, headless: bool = True) -> Dict[str, Any]:
+    """
+    🔍 Search forum posts on WorldQuant BRAIN support site.
+    
+    Note: This requires Selenium and is implemented in forum_functions.py
+    
+    Args:
+        email: Your BRAIN platform email address (optional if in config)
+        password: Your BRAIN platform password (optional if in config)
+        search_query: Search term or phrase
+        max_results: Maximum number of results to return (default: 50)
+        headless: Run browser in headless mode (default: True)
+    
+    Returns:
+        Search results with analysis
+    """
+    try:
+        # Load config to get credentials if not provided
+        config = load_config()
+        
+        # Use provided credentials or fall back to config
+        if not email and 'credentials' in config:
+            email = config['credentials'].get('email', '')
+        if not password and 'credentials' in config:
+            password = config['credentials'].get('password', '')
+        
+        if not email or not password:
+            return {"error": "Email and password required. Either provide them as arguments or configure them in user_config.json"}
+        
+        return await brain_client.search_forum_posts(email, password, search_query, max_results, headless)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def read_forum_post(article_id: str, email: str = "", password: str = "", 
+                        headless: bool = False) -> Dict[str, Any]:
+    """
+    📄 Get a specific forum post by article ID.
+    
+    Note: This requires Selenium and is implemented in forum_functions.py
+    
+    Args:
+        article_id: The article ID to retrieve (e.g., "32984819083415-新人求模板")
+        email: Your BRAIN platform email address (optional if in config)
+        password: Your BRAIN platform password (optional if in config)
+        headless: Run browser in headless mode (default: False)
+    
+    Returns:
+        Forum post content with comments
+    """
+    try:
+        # Load config to get credentials if not provided
+        config = load_config()
+        
+        # Use provided credentials or fall back to config
+        if not email and 'credentials' in config:
+            email = config['credentials'].get('email', '')
+        if not password and 'credentials' in config:
+            password = config['credentials'].get('password', '')
+        
+        if not email or not password:
+            return {"error": "Email and password required. Either provide them as arguments or configure them in user_config.json"}
+        
+        # Import and use forum functions directly
+        from forum_functions import forum_client
+        return await forum_client.read_full_forum_post(email, password, article_id, headless, include_comments=True)
+    except ImportError:
+        return {"error": "Forum functions require selenium. Use forum_functions.py directly."}
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_alpha_yearly_stats(alpha_id: str) -> Dict[str, Any]:
+    """Get yearly statistics for an alpha."""
+    try:
+        return await brain_client.get_alpha_yearly_stats(alpha_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def check_correlation(alpha_id: str, correlation_type: str = "both", threshold: float = 0.7) -> Dict[str, Any]:
+    """Check alpha correlation against production alphas, self alphas, or both."""
+    try:
+        return await brain_client.check_correlation(alpha_id, correlation_type, threshold)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_submission_check(alpha_id: str) -> Dict[str, Any]:
+    """Comprehensive pre-submission check."""
+    try:
+        return await brain_client.get_submission_check(alpha_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def set_alpha_properties(alpha_id: str, name: Optional[str] = None, 
+                             color: Optional[str] = None, tags: List[str] = None,
+                             selection_desc: str = "None", combo_desc: str = "None") -> Dict[str, Any]:
+    """Update alpha properties (name, color, tags, descriptions)."""
+    try:
+        return await brain_client.set_alpha_properties(alpha_id, name, color, tags, selection_desc, combo_desc)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_record_sets(alpha_id: str) -> Dict[str, Any]:
+    """List available record sets for an alpha."""
+    try:
+        return await brain_client.get_record_sets(alpha_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_record_set_data(alpha_id: str, record_set_name: str) -> Dict[str, Any]:
+    """Get data from a specific record set."""
+    try:
+        return await brain_client.get_record_set_data(alpha_id, record_set_name)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_user_activities(user_id: str, grouping: Optional[str] = None) -> Dict[str, Any]:
+    """Get user activity diversity data."""
+    try:
+        return await brain_client.get_user_activities(user_id, grouping)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_pyramid_multipliers() -> Dict[str, Any]:
+    """Get current pyramid multipliers showing BRAIN's encouragement levels."""
+    try:
+        return await brain_client.get_pyramid_multipliers()
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_pyramid_alphas(start_date: Optional[str] = None,
+                           end_date: Optional[str] = None) -> Dict[str, Any]:
+    """Get user's current alpha distribution across pyramid categories."""
+    try:
+        return await brain_client.get_pyramid_alphas(start_date, end_date)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_user_competitions(user_id: Optional[str] = None) -> Dict[str, Any]:
+    """Get list of competitions that the user is participating in."""
+    try:
+        return await brain_client.get_user_competitions(user_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_competition_details(competition_id: str) -> Dict[str, Any]:
+    """Get detailed information about a specific competition."""
+    try:
+        return await brain_client.get_competition_details(competition_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_competition_agreement(competition_id: str) -> Dict[str, Any]:
+    """Get the rules, terms, and agreement for a specific competition."""
+    try:
+        return await brain_client.get_competition_agreement(competition_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def get_platform_setting_options() -> Dict[str, Any]:
+    """Discover valid simulation setting options (instrument types, regions, delays, universes, neutralization).
+
+    Use this when a simulation request might contain an invalid/mismatched setting. If an AI or user supplies
+    incorrect parameters (e.g., wrong region for an instrument type), call this tool to retrieve the authoritative
+    option sets and correct the inputs before proceeding.
+
+    Returns:
+        A structured list of valid combinations and choice lists to validate or fix simulation settings.
+    """
+    try:
+        return await brain_client.get_platform_setting_options()
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+async def performance_comparison(alpha_id: str, team_id: Optional[str] = None, 
+                               competition: Optional[str] = None) -> Dict[str, Any]:
+    """Get performance comparison data for an alpha."""
+    try:
+        return await brain_client.performance_comparison(alpha_id, team_id, competition)
+    except Exception as e:
+        return {"error": str(e)}
+
+# combine_test_results MCP tool removed as requested
+
+@mcp.tool()
+async def expand_nested_data(data: List[Dict[str, Any]], preserve_original: bool = True) -> List[Dict[str, Any]]:
+    """Flatten complex nested data structures into tabular format."""
+    try:
+        return await brain_client.expand_nested_data(data, preserve_original)
+    except Exception as e:
+        return {"error": str(e)}
+
+# generate_alpha_links MCP tool removed as requested
+
+@mcp.tool()
+async def read_specific_documentation(page_id: str) -> Dict[str, Any]:
+    """Retrieve detailed content of a specific documentation page/article."""
+    try:
+        return await brain_client.read_specific_documentation(page_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+# Badge status MCP tool removed as requested
+
+@mcp.tool()
+async def create_multiSim(
+    alpha_expressions: List[str],
+    instrument_type: str = "EQUITY",
+    region: str = "USA",
+    universe: str = "TOP3000",
+    delay: int = 1,
+    decay: float = 0.0,
+    neutralization: str = "NONE",
+    truncation: float = 0.0,
+    test_period: str = "P0Y0M",
+    unit_handling: str = "VERIFY",
+    nan_handling: str = "OFF",
+    language: str = "FASTEXPR",
+    visualization: bool = True,
+    pasteurization: str = "ON",
+    max_trade: str = "OFF"
+) -> Dict[str, Any]:
+    """
+    🚀 Create multiple regular alpha simulations on BRAIN platform in a single request.
+    
+    This tool creates a multisimulation with multiple regular alpha expressions,
+    waits for all simulations to complete, and returns detailed results for each alpha.
+    
+    ⏰ NOTE: Multisimulations can take 8+ minutes to complete. This tool will wait
+    for the entire process and return comprehensive results.
+    Call get_platform_setting_options to get the valid options for the simulation.
+    Args:
+        alpha_expressions: List of alpha expressions (2-8 expressions required)
+        instrument_type: Type of instruments (default: "EQUITY")
+        region: Market region (default: "USA")
+        universe: Universe of stocks (default: "TOP3000")
+        delay: Data delay (default: 1)
+        decay: Decay value (default: 0.0)
+        neutralization: Neutralization method (default: "NONE")
+        truncation: Truncation value (default: 0.0)
+        test_period: Test period (default: "P0Y0M")
+        unit_handling: Unit handling method (default: "VERIFY")
+        nan_handling: NaN handling method (default: "OFF")
+        language: Expression language (default: "FASTEXPR")
+        visualization: Enable visualization (default: True)
+        pasteurization: Pasteurization setting (default: "ON")
+        max_trade: Max trade setting (default: "OFF")
+    
+    Returns:
+        Dictionary containing multisimulation results and individual alpha details
+    """
+    try:
+        # Validate input
+        if len(alpha_expressions) < 2:
+            return {"error": "At least 2 alpha expressions are required"}
+        if len(alpha_expressions) > 8:
+            return {"error": "Maximum 8 alpha expressions allowed per request"}
+        
+        # Create multisimulation data
+        multisimulation_data = []
+        for alpha_expr in alpha_expressions:
+            simulation_item = {
+                'type': 'REGULAR',
+                'settings': {
+                    'instrumentType': instrument_type,
+                    'region': region,
+                    'universe': universe,
+                    'delay': delay,
+                    'decay': decay,
+                    'neutralization': neutralization,
+                    'truncation': truncation,
+                    'pasteurization': pasteurization,
+                    'unitHandling': unit_handling,
+                    'nanHandling': nan_handling,
+                    'language': language,
+                    'visualization': visualization,
+                    'testPeriod': test_period,
+                    'maxTrade': max_trade
+                },
+                'regular': alpha_expr
+            }
+            multisimulation_data.append(simulation_item)
+        
+        # Send multisimulation request
+        response = brain_client.session.post(f"{brain_client.base_url}/simulations", json=multisimulation_data)
+        
+        if response.status_code != 201:
+            return {"error": f"Failed to create multisimulation. Status: {response.status_code},, you need to call three mcp tools get_operators, get_platform_setting_options and get_datafields to check whether you correctly use the operators, setting the simulation settings, and existing data fields."}
+        
+        # Get multisimulation location
+        location = response.headers.get('Location', '')
+        if not location:
+            return {"error": "No location header in multisimulation response"}
+        
+        # Wait for children to appear and get results
+        return await _wait_for_multisimulation_completion(location, len(alpha_expressions))
+        
+    except Exception as e:
+        return {"error": f"Error creating multisimulation: {str(e)}, , you need to call three mcp tools get_operators, get_platform_setting_options and get_datafields to check whether you correctly use the operators, setting the simulation settings, and existing data fields."}
+
+async def _wait_for_multisimulation_completion(location: str, expected_children: int) -> Dict[str, Any]:
+    """Wait for multisimulation to complete and return results"""
+    try:
+        # Simple progress indicator for users
+        print(f"Waiting for multisimulation to complete... (this may take several minutes)")
+        print(f"Expected {expected_children} alpha simulations")
+        print()
+        # Wait for children to appear - much more tolerant for 8+ minute multisimulations
+        children = []
+        max_wait_attempts = 200  # Increased significantly for 8+ minute multisimulations
+        wait_attempt = 0
+        
+        while wait_attempt < max_wait_attempts and len(children) == 0:
+            wait_attempt += 1
+            
+            try:
+                multisim_response = brain_client.session.get(location)
+                if multisim_response.status_code == 200:
+                    multisim_data = multisim_response.json()
+                    children = multisim_data.get('children', [])
+                    
+                    if children:
+                        break
+                    else:
+                        # Wait before next attempt - use longer intervals for multisimulations
+                        retry_after = multisim_response.headers.get("Retry-After", 5)
+                        wait_time = float(retry_after)
+                        await asyncio.sleep(wait_time)
+                else:
+                    await asyncio.sleep(5)
+            except Exception as e:
+                await asyncio.sleep(5)
+        
+        if not children:
+            return {"error": f"Children did not appear within {max_wait_attempts} attempts (multisimulation may still be processing)"}
+        
+        # Process each child to get alpha results
+        alpha_results = []
+        for i, child_id in enumerate(children):
+            try:
+                # The children are full URLs, not just IDs
+                child_url = child_id if child_id.startswith('http') else f"{brain_client.base_url}/simulations/{child_id}"
+                
+                # Wait for this alpha to complete - more tolerant timing
+                finished = False
+                max_alpha_attempts = 100  # Increased for longer alpha processing
+                alpha_attempt = 0
+                
+                while not finished and alpha_attempt < max_alpha_attempts:
+                    alpha_attempt += 1
+                    
+                    try:
+                        alpha_progress = brain_client.session.get(child_url)
+                        if alpha_progress.status_code == 200:
+                            alpha_data = alpha_progress.json()
+                            retry_after = alpha_progress.headers.get("Retry-After", 0)
+                            
+                            if retry_after == 0:
+                                finished = True
+                                break
+                            else:
+                                wait_time = float(retry_after)
+                                await asyncio.sleep(wait_time)
+                        else:
+                            await asyncio.sleep(5)
+                    except Exception as e:
+                        await asyncio.sleep(5)
+                
+                if finished:
+                    # Get alpha details from the completed simulation
+                    alpha_id = alpha_data.get("alpha")
+                    if alpha_id:
+                        # Now get the actual alpha details from the alpha endpoint
+                        alpha_details = brain_client.session.get(f"{brain_client.base_url}/alphas/{alpha_id}")
+                        if alpha_details.status_code == 200:
+                            alpha_detail_data = alpha_details.json()
+                            alpha_results.append({
+                                'alpha_id': alpha_id,
+                                'location': child_url,
+                                'details': alpha_detail_data
+                            })
+                        else:
+                            alpha_results.append({
+                                'alpha_id': alpha_id,
+                                'location': child_url,
+                                'error': f'Failed to get alpha details: {alpha_details.status_code}'
+                            })
+                    else:
+                        alpha_results.append({
+                            'location': child_url,
+                            'error': 'No alpha ID found in completed simulation'
+                        })
+                else:
+                    alpha_results.append({
+                        'location': child_url,
+                        'error': f'Alpha simulation did not complete within {max_alpha_attempts} attempts'
+                    })
+                    
+            except Exception as e:
+                alpha_results.append({
+                    'location': f"child_{i+1}",
+                    'error': str(e)
+                })
+        
+        # Return comprehensive results
+        print(f"Multisimulation completed! Retrieved {len(alpha_results)} alpha results")
+        return {
+            'success': True,
+            'message': f'Successfully created {expected_children} regular alpha simulations',
+            'total_requested': expected_children,
+            'total_created': len(alpha_results),
+            'multisimulation_id': location.split('/')[-1],
+            'multisimulation_location': location,
+            'alpha_results': alpha_results,
+            'note': "if you got a negative alpha sharpe, you can just add a minus sign in front of the last line of the Alpha to flip then think the next step."
+        }
+        
+    except Exception as e:
+        return {"error": f"Error waiting for multisimulation completion: {str(e)}, you need to call three mcp tools get_operators, get_platform_setting_options and get_datafields to check whether you correctly use the operators, setting the simulation settings, and existing data fields."}
+
+@mcp.tool()
+async def get_daily_and_quarterly_payment(email: str = "", password: str = "") -> Dict[str, Any]:
+    """
+    Get daily and quarterly payment information from WorldQuant BRAIN platform.
+    
+    This function retrieves both base payments (daily alpha performance payments) and 
+    other payments (competition rewards, quarterly payments, referrals, etc.).
+    
+    Args:
+        email: Your BRAIN platform email address (optional if in config)
+        password: Your BRAIN platform password (optional if in config)
+    
+    Returns:
+        Dictionary containing base payment and other payment data with summaries and detailed records
+    """
+    try:
+        # Authenticate if credentials provided
+        if email and password:
+            auth_result = await brain_client.authenticate(email, password)
+            if auth_result.get('status') != 'authenticated':
+                return {"error": f"Authentication failed: {auth_result.get('message', 'Unknown error')}"}
+        else:
+            # Try to use existing session or config
+            config = await manage_config("get")
+            if not config.get('is_authenticated'):
+                return {"error": "Not authenticated. Please provide email and password or authenticate first."}
+        
+
+        # Set required Accept header for API v3.0
+        header = {"Accept": "application/json;version=3.0"}
+
+        # Get base payment data
+        base_payment_response = brain_client.session.get(
+            'https://api.worldquantbrain.com/users/self/activities/base-payment', headers=header
+        )
+
+        if base_payment_response.status_code != 200:
+            return {"error": f"Failed to get base payment data: {base_payment_response.status_code}"}
+
+        base_payment_data = base_payment_response.json()
+
+        # Get other payment data
+        other_payment_response = brain_client.session.get(
+            'https://api.worldquantbrain.com/users/self/activities/other-payment', headers=header
+        )
+
+        if other_payment_response.status_code != 200:
+            return {"error": f"Failed to get other payment data: {other_payment_response.status_code}"}
+
+        other_payment_data = other_payment_response.json()
+        
+        # Return comprehensive payment information
+        return {
+            "success": True,
+            "base_payment": {
+                "summary": {
+                    "yesterday": base_payment_data.get("yesterday"),
+                    "current_quarter": base_payment_data.get("current"),
+                    "previous_quarter": base_payment_data.get("previous"),
+                    "year_to_date": base_payment_data.get("ytd"),
+                    "total_all_time": base_payment_data.get("total"),
+                    "currency": base_payment_data.get("currency")
+                },
+                "daily_records": base_payment_data.get("records", {}).get("records", []),
+                "schema": base_payment_data.get("records", {}).get("schema")
+            },
+            "other_payment": {
+                "total_all_time": other_payment_data.get("total"),
+                "special_payments": other_payment_data.get("records", {}).get("records", []),
+                "schema": other_payment_data.get("records", {}).get("schema"),
+                "currency": other_payment_data.get("currency")
+            },
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        return {"error": f"Error retrieving payment information: {str(e)}"}
+
+
+
+# New MCP tool: get_SimError_detail
+from typing import Sequence
+@mcp.tool()
+async def get_SimError_detail(locations: Sequence[str]) -> dict:
+    """
+    Fetch and parse error/status from multiple simulation locations (URLs).
+    Args:
+        locations: List of simulation result URLs (e.g., /simulations/{id})
+    Returns:
+        List of dicts with location, error message, and raw response
+    """
+    results = []
+    for loc in locations:
+        try:
+            resp = brain_client.session.get(loc)
+            if resp.status_code != 200:
+                results.append({
+                    "location": loc,
+                    "error": f"HTTP {resp.status_code}",
+                    "raw": resp.text
+                })
+                continue
+            data = resp.json() if resp.text else {}
+            # Try to extract error message or status
+            error_msg = data.get("error") or data.get("message")
+            # If alpha ID is missing, include that info
+            if not data.get("alpha"):
+                error_msg = error_msg or "Simulation did not get through, if you are running a multisimulation, check the other children location in your request"
+            results.append({
+                "location": loc,
+                "error": error_msg,
+                "raw": data
+            })
+        except Exception as e:
+            results.append({
+                "location": loc,
+                "error": str(e),
+                "raw": None
+            })
+    return {"results": results}
+
+if __name__ == "__main__":
+    try:
+        print("WorldQuant BRAIN MCP Server Starting...", file=sys.stderr)
+        mcp.run()
+    except Exception as e:
+        print(f"Failed to start MCP server: {e}", file=sys.stderr)
+        sys.exit(1)
+