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

cnhkmcp/untracked/platform_functions.py

@@ -1,40 +1,33 @@
 #!/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 typing import Dict, List, Optional, Any, Union, Tuple
+import re
+import base64
+from bs4 import BeautifulSoup
 from dataclasses import dataclass, asdict
 from datetime import datetime, timedelta
+import os
+import sys
 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
 
+# Import the new forum client
+from forum_functions import forum_client
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -178,33 +171,18 @@ class BrainApiClient:
         self.log("🌐 Starting biometric authentication...", "INFO")
         
         try:
-            # Import selenium for browser automation
-            from selenium import webdriver
-            from selenium.webdriver.chrome.options import Options
+            # Import playwright for browser automation
+            from playwright.async_api import async_playwright
             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
-                
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=False)
+                page = await browser.new_page()
+
                 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")
-                
+                await page.goto(biometric_url)
+                self.log("Browser page loaded successfully", "SUCCESS")
+
                 # Print instructions
                 print("\n" + "="*60, file=sys.stderr)
                 print("BIOMETRIC AUTHENTICATION REQUIRED", file=sys.stderr)
@@ -213,24 +191,23 @@ class BrainApiClient:
                 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()
+
+                        await browser.close()
                         
                         # Check JWT token
                         jwt_token = self.session.cookies.get('t')
@@ -247,19 +224,9 @@ class BrainApiClient:
                             'has_jwt': jwt_token is not None
                         }
                 
-                # If we get here, authentication timed out
-                if driver:
-                    driver.quit()
+                await browser.close()
                 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
@@ -289,11 +256,19 @@ class BrainApiClient:
     
     async def ensure_authenticated(self):
         """Ensure authentication is valid, re-authenticate if needed."""
-        if not await self.is_authenticated() and self.auth_credentials:
+        if not await self.is_authenticated():
+            if not self.auth_credentials:
+                self.log("No credentials in memory, loading from config...", "INFO")
+                config = load_config()
+                creds = config.get("credentials", {})
+                email = creds.get("email")
+                password = creds.get("password")
+                if not email or not password:
+                    raise Exception("Authentication credentials not found in config. Please authenticate first.")
+                self.auth_credentials = {'email': email, 'password': password}
+
             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."""
@@ -313,7 +288,7 @@ class BrainApiClient:
             self.log("🚀 Creating simulation...", "INFO")
             
             # Prepare settings based on simulation type
-            settings_dict = simulation_data.settings.dict()
+            settings_dict = simulation_data.settings.model_dump()
             
             # Remove fields based on simulation type
             if simulation_data.type == "REGULAR":
@@ -321,9 +296,6 @@ class BrainApiClient:
                 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}
@@ -347,21 +319,14 @@ class BrainApiClient:
             # 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:
@@ -379,9 +344,6 @@ class BrainApiClient:
             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()
@@ -393,36 +355,8 @@ class BrainApiClient:
         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", 
+    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()
@@ -441,9 +375,9 @@ class BrainApiClient:
             
             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
+            response_json = response.json()
+            response_json['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_json
         except Exception as e:
             self.log(f"Failed to get datasets: {str(e)}", "ERROR")
             raise
@@ -475,9 +409,9 @@ class BrainApiClient:
             
             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
+            response_json = response.json()
+            response_json['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_json
         except Exception as e:
             self.log(f"Failed to get datafields: {str(e)}", "ERROR")
             raise
@@ -639,6 +573,150 @@ class BrainApiClient:
             self.log(f"Failed to get leaderboard: {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 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_operators(self) -> Dict[str, Any]:
         """Get available operators for alpha creation."""
         await self.ensure_authenticated()
@@ -656,7 +734,7 @@ class BrainApiClient:
         except Exception as e:
             self.log(f"Failed to get operators: {str(e)}", "ERROR")
             raise
-
+            
     async def run_selection(
         self,
         selection: str,
@@ -697,7 +775,7 @@ class BrainApiClient:
         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()
@@ -709,9 +787,7 @@ class BrainApiClient:
         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.
 
@@ -847,47 +923,32 @@ class BrainApiClient:
             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]:
+    async def get_glossary_terms(self, email: str, password: str) -> List[Dict[str, str]]:
         """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."}
+            return await forum_client.get_glossary_terms(email, password)
         except Exception as e:
-            self.log(f"Glossary extraction failed: {str(e)}", "ERROR")
-            return {"error": str(e)}
+            self.log(f"Failed to get glossary terms: {str(e)}", "ERROR")
+            raise
 
     async def search_forum_posts(self, email: str, password: str, search_query: str, 
-                               max_results: int = 50, headless: bool = True) -> Dict[str, Any]:
+                                 max_results: int = 50) -> 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."}
+            return await forum_client.search_forum_posts(email, password, search_query, max_results)
         except Exception as e:
-            self.log(f"Forum search failed: {str(e)}", "ERROR")
-            return {"error": str(e)}
+            self.log(f"Failed to search forum posts: {str(e)}", "ERROR")
+            raise
 
     async def read_forum_post(self, email: str, password: str, article_id: str, 
-                           headless: bool = False) -> Dict[str, Any]:
+                              include_comments: bool = True) -> 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."}
+            return await forum_client.read_full_forum_post(email, password, article_id, include_comments)
         except Exception as e:
-            self.log(f"Forum post retrieval failed: {str(e)}", "ERROR")
-            return {"error": str(e)}
-
+            self.log(f"Failed to read forum post: {str(e)}", "ERROR")
+            raise
+    
     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()
@@ -951,7 +1012,7 @@ class BrainApiClient:
         
         # 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()
@@ -1183,8 +1244,8 @@ class BrainApiClient:
             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]:
+                                   color: Optional[str] = None, tags: Optional[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()
         
@@ -1253,7 +1314,6 @@ class BrainApiClient:
         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()
@@ -1261,125 +1321,9 @@ class BrainApiClient:
             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."""
+    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:
@@ -1419,7 +1363,7 @@ class BrainApiClient:
         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()
@@ -1440,7 +1384,7 @@ class BrainApiClient:
         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()
@@ -1452,7 +1396,7 @@ class BrainApiClient:
         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()
@@ -1532,18 +1476,15 @@ class BrainApiClient:
         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]:
+                                     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
+            params = {"teamId": team_id, "competition": competition}
+            params = {k: v for k, v in params.items() if v is not None}
             
             response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/performance-comparison", params=params)
             response.raise_for_status()
@@ -1551,48 +1492,25 @@ class BrainApiClient:
         except Exception as e:
             self.log(f"Failed to get performance comparison: {str(e)}", "ERROR")
             raise
-
-    # combine_test_results function removed as requested
-
+            
+    # --- Helper function for data flattening ---
+    
     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
+            df = pd.json_normalize(data, sep='_')
+            if preserve_original:
+                original_df = pd.DataFrame(data)
+                df = pd.concat([original_df, df], axis=1)
+                df = df.loc[:,~df.columns.duplicated()]
+            return df.to_dict(orient='records')
         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]:
+            
+    # --- New documentation endpoint ---
+    
+    async def get_documentation_page(self, page_id: str) -> Dict[str, Any]:
         """Retrieve detailed content of a specific documentation page/article."""
         await self.ensure_authenticated()
         
@@ -1604,88 +1522,64 @@ class BrainApiClient:
             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"
+# --- Configuration Management ---
 
 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.
+    Resolve the configuration file path.
+    
+    Checks for a file specified by the MCP_CONFIG_FILE environment variable,
+    then falls back to ~/.brain_mcp_config.json. If for_write is True,
+    it ensures the directory exists.
     """
-    # 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())
+    if 'MCP_CONFIG_FILE' in os.environ:
+        return os.environ['MCP_CONFIG_FILE']
+    
+    config_path = Path(__file__).parent / "user_config.json"
+    
+    if for_write:
+        try:
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+        except (IOError, OSError) as e:
+            logger.warning(f"Could not create config directory {config_path.parent}: {e}")
+            # Fallback to a temporary file if home is not writable
+            import tempfile
+            return tempfile.NamedTemporaryFile(delete=False).name
+            
+    return str(config_path)
 
 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):
+    """Load configuration from file."""
+    config_file = _resolve_config_path()
+    if os.path.exists(config_file):
         try:
-            with open(path, 'r', encoding='utf-8') as f:
+            with open(config_file, 'r', encoding='utf-8') as f:
                 return json.load(f)
-        except Exception as e:
-            logger.error(f"Failed to load config from '{path}': {e}")
+        except (IOError, json.JSONDecodeError) as e:
+            logger.error(f"Error loading config file {config_file}: {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.
+    
+    This function now uses the write-enabled path resolver to handle
+    cases where the default home directory is not writable.
     """
+    config_file = _resolve_config_path(for_write=True)
     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}")
+        with open(config_file, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2)
+    except IOError as e:
+        logger.error(f"Error saving config file to {config_file}: {e}")
 
-# MCP Tools
+# --- MCP Tool Definitions ---
+
+mcp = FastMCP(
+    "brain-platform-mcp",
+    "A server for interacting with the WorldQuant BRAIN platform",
+)
 
 @mcp.tool()
 async def authenticate(email: Optional[str] = "", password: Optional[str] = "") -> Dict[str, Any]:
@@ -1702,48 +1596,27 @@ async def authenticate(email: Optional[str] = "", password: Optional[str] = "")
         Authentication result with user info and permissions
     """
     try:
+        # Load config to get credentials if not provided
         config = load_config()
-        if 'credentials' in config:
-            if not email:
-                email = config['credentials'].get('email', '')
-            if not password:
-                password = config['credentials'].get('password', '')
-        
+        credentials = config.get("credentials", {})
+        email = email or credentials.get("email")
+        password = password or 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\"]"}
+            return {"error": "Authentication credentials not provided or found in config."}
         
-        result = await brain_client.authenticate(email, password)
+        auth_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)
+        # Save successful credentials
+        if auth_result.get('status') == 'authenticated':
+            if 'credentials' not in config:
+                config['credentials'] = {}
+            config['credentials']['email'] = email
+            config['credentials']['password'] = password
+            save_config(config)
+            
+        return auth_result
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def manage_config(action: str = "get", settings: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
@@ -1779,6 +1652,8 @@ async def manage_config(action: str = "get", settings: Optional[Dict[str, Any]]
     else:
         return {"error": f"Invalid action '{action}'. Use 'get' or 'set'."}
 
+# --- Simulation Tools ---
+
 @mcp.tool()
 async def create_simulation(
     type: str = "REGULAR",
@@ -1801,7 +1676,7 @@ async def create_simulation(
     max_trade: str = "OFF",
     selection_handling: str = "POSITIVE",
     selection_limit: int = 1000,
-    component_activation: str = "IS"
+    component_activation: str = "IS",
 ) -> Dict[str, Any]:
     """
     🚀 Create a new simulation on BRAIN platform.
@@ -1842,10 +1717,15 @@ async def create_simulation(
             unitHandling=unit_handling,
             nanHandling=nan_handling,
             language=language,
-            visualization=visualization
+            visualization=visualization,
+            pasteurization=pasteurization,
+            maxTrade=max_trade,
+            selectionHandling=selection_handling,
+            selectionLimit=selection_limit,
+            componentActivation=component_activation,
         )
         
-        simulation_data = SimulationData(
+        sim_data = SimulationData(
             type=type,
             settings=settings,
             regular=regular,
@@ -1853,13 +1733,11 @@ async def create_simulation(
             selection=selection
         )
         
-        result = await brain_client.create_simulation(simulation_data)
-        return result
+        return await brain_client.create_simulation(sim_data)
     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."}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
-# get_simulation_status MCP tool removed as requested
-# wait_for_simulation MCP tool removed as requested
+# --- Alpha and Data Retrieval Tools ---
 
 @mcp.tool()
 async def get_alpha_details(alpha_id: str) -> Dict[str, Any]:
@@ -1875,7 +1753,7 @@ async def get_alpha_details(alpha_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_alpha_details(alpha_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_datasets(
@@ -1884,7 +1762,7 @@ async def get_datasets(
     delay: int = 1,
     universe: str = "TOP3000",
     theme: str = "false",
-    search: Optional[str] = None
+    search: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     📚 Get available datasets for research.
@@ -1902,9 +1780,9 @@ async def get_datasets(
         Available datasets
     """
     try:
-        return await brain_client.get_datasets(instrument_type, region, delay, universe, theme,search)
+        return await brain_client.get_datasets(instrument_type, region, delay, universe, theme, search)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_datafields(
@@ -1915,7 +1793,7 @@ async def get_datafields(
     theme: str = "false",
     dataset_id: Optional[str] = None,
     data_type: str = "",
-    search: Optional[str] = None
+    search: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     🔍 Get available data fields for alpha construction.
@@ -1929,19 +1807,16 @@ async def get_datafields(
         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")
+        data_type: Type of data (e.g., "MATRIX",'VECTOR','GROUP')
         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
-        )
+        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)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_alpha_pnl(alpha_id: str) -> Dict[str, Any]:
@@ -1957,7 +1832,7 @@ async def get_alpha_pnl(alpha_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_alpha_pnl(alpha_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_user_alphas(
@@ -2013,18 +1888,12 @@ async def get_user_alphas(
     """
     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,
+            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)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def submit_alpha(alpha_id: str) -> Dict[str, Any]:
@@ -2041,10 +1910,30 @@ async def submit_alpha(alpha_id: str) -> Dict[str, Any]:
     """
     try:
         success = await brain_client.submit_alpha(alpha_id)
-        return {"submit_result": success, "alpha_id": alpha_id}
+        return {"success": success}
+    except Exception as e:
+        return {"error": f"An unexpected error occurred: {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)}
 
+# --- Community and Events Tools ---
+
 @mcp.tool()
 async def get_events() -> Dict[str, Any]:
     """
@@ -2056,7 +1945,7 @@ async def get_events() -> Dict[str, Any]:
     try:
         return await brain_client.get_events()
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_leaderboard(user_id: Optional[str] = None) -> Dict[str, Any]:
@@ -2072,35 +1961,10 @@ async def get_leaderboard(user_id: Optional[str] = None) -> Dict[str, Any]:
     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)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 
+# --- Forum Tools ---
 
 @mcp.tool()
 async def get_operators() -> Dict[str, Any]:
@@ -2111,9 +1975,12 @@ async def get_operators() -> Dict[str, Any]:
         Dictionary containing operators list and count
     """
     try:
-        return await brain_client.get_operators()
+        operators = await brain_client.get_operators()
+        if isinstance(operators, list):
+            return {"results": operators, "count": len(operators)}
+        return operators
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def run_selection(
@@ -2122,7 +1989,7 @@ async def run_selection(
     region: str = "USA",
     delay: int = 1,
     selection_limit: int = 1000,
-    selection_handling: str = "POSITIVE"
+    selection_handling: str = "POSITIVE",
 ) -> Dict[str, Any]:
     """
     🎯 Run a selection query to filter instruments.
@@ -2143,7 +2010,7 @@ async def run_selection(
             selection, instrument_type, region, delay, selection_limit, selection_handling
         )
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_user_profile(user_id: str = "self") -> Dict[str, Any]:
@@ -2159,7 +2026,7 @@ async def get_user_profile(user_id: str = "self") -> Dict[str, Any]:
     try:
         return await brain_client.get_user_profile(user_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_documentations() -> Dict[str, Any]:
@@ -2172,226 +2039,110 @@ async def get_documentations() -> Dict[str, Any]:
     try:
         return await brain_client.get_documentations()
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
-# get_messages_summary MCP tool removed as requested
+# --- Message and Forum Tools ---
 
 @mcp.tool()
-async def get_messages(limit: Optional[int] = 0, offset: int = 0) -> Dict[str, Any]:
+async def get_messages(limit: Optional[int] = None, offset: int = 0) -> Dict[str, Any]:
     """
-    Get messages for the current user with optional pagination.
+    💬 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))
-            }
-        }
+        return await brain_client.get_messages(limit, 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))
-            }
-        }
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
-async def get_glossary_terms(email: str = "", password: str = "", headless: bool = False) -> Dict[str, Any]:
+async def get_glossary_terms(email: str = "", password: str = "") -> List[Dict[str, str]]:
     """
     📚 Get glossary terms from WorldQuant BRAIN forum.
     
-    Note: This requires Selenium and is implemented in forum_functions.py
+    Note: This uses Playwright 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
+        A list of 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', '')
-        
+        credentials = config.get("credentials", {})
+        email = email or credentials.get("email")
+        password = password or 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"}
+            raise ValueError("Authentication credentials not provided or found in config.")
         
-        return await brain_client.get_glossary_terms(email, password, headless)
+        return await brain_client.get_glossary_terms(email, password)
     except Exception as e:
-        return {"error": str(e)}
+        logger.error(f"Error in get_glossary_terms tool: {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]:
+                             max_results: int = 50) -> Dict[str, Any]:
     """
     🔍 Search forum posts on WorldQuant BRAIN support site.
     
-    Note: This requires Selenium and is implemented in forum_functions.py
+    Note: This uses Playwright and is implemented in forum_functions.py
     
     Args:
+        search_query: Search term or phrase
         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', '')
-        
+        credentials = config.get("credentials", {})
+        email = email or credentials.get("email")
+        password = password or 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)
+            return {"error": "Authentication credentials not provided or found in config."}
+            
+        return await brain_client.search_forum_posts(email, password, search_query, max_results)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def read_forum_post(article_id: str, email: str = "", password: str = "", 
-                        headless: bool = False) -> Dict[str, Any]:
+                          include_comments: bool = True) -> Dict[str, Any]:
     """
     📄 Get a specific forum post by article ID.
     
-    Note: This requires Selenium and is implemented in forum_functions.py
+    Note: This uses Playwright 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', '')
-        
+        credentials = config.get("credentials", {})
+        email = email or credentials.get("email")
+        password = password or 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."}
+            return {"error": "Authentication credentials not provided or found in config."}
+
+        return await brain_client.read_forum_post(email, password, article_id, include_comments)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_alpha_yearly_stats(alpha_id: str) -> Dict[str, Any]:
@@ -2399,7 +2150,7 @@ async def get_alpha_yearly_stats(alpha_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_alpha_yearly_stats(alpha_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def check_correlation(alpha_id: str, correlation_type: str = "both", threshold: float = 0.7) -> Dict[str, Any]:
@@ -2407,7 +2158,7 @@ async def check_correlation(alpha_id: str, correlation_type: str = "both", thres
     try:
         return await brain_client.check_correlation(alpha_id, correlation_type, threshold)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_submission_check(alpha_id: str) -> Dict[str, Any]:
@@ -2415,17 +2166,17 @@ async def get_submission_check(alpha_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_submission_check(alpha_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {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]:
+                               color: Optional[str] = None, tags: Optional[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)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_record_sets(alpha_id: str) -> Dict[str, Any]:
@@ -2433,7 +2184,7 @@ async def get_record_sets(alpha_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_record_sets(alpha_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_record_set_data(alpha_id: str, record_set_name: str) -> Dict[str, Any]:
@@ -2441,7 +2192,7 @@ async def get_record_set_data(alpha_id: str, record_set_name: str) -> Dict[str,
     try:
         return await brain_client.get_record_set_data(alpha_id, record_set_name)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_user_activities(user_id: str, grouping: Optional[str] = None) -> Dict[str, Any]:
@@ -2449,7 +2200,7 @@ async def get_user_activities(user_id: str, grouping: Optional[str] = None) -> D
     try:
         return await brain_client.get_user_activities(user_id, grouping)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_pyramid_multipliers() -> Dict[str, Any]:
@@ -2457,24 +2208,24 @@ async def get_pyramid_multipliers() -> Dict[str, Any]:
     try:
         return await brain_client.get_pyramid_multipliers()
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_pyramid_alphas(start_date: Optional[str] = None,
-                           end_date: Optional[str] = None) -> Dict[str, Any]:
+                               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)}
-
+        return {"error": f"An unexpected error occurred: {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)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_competition_details(competition_id: str) -> Dict[str, Any]:
@@ -2482,7 +2233,7 @@ async def get_competition_details(competition_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_competition_details(competition_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_competition_agreement(competition_id: str) -> Dict[str, Any]:
@@ -2490,7 +2241,7 @@ async def get_competition_agreement(competition_id: str) -> Dict[str, Any]:
     try:
         return await brain_client.get_competition_agreement(competition_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def get_platform_setting_options() -> Dict[str, Any]:
@@ -2506,18 +2257,18 @@ async def get_platform_setting_options() -> Dict[str, Any]:
     try:
         return await brain_client.get_platform_setting_options()
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
 @mcp.tool()
 async def performance_comparison(alpha_id: str, team_id: Optional[str] = None, 
-                               competition: Optional[str] = None) -> Dict[str, Any]:
+                                 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
+        return {"error": f"An unexpected error occurred: {str(e)}"}
+        
+# --- Dataframe Tool ---
 
 @mcp.tool()
 async def expand_nested_data(data: List[Dict[str, Any]], preserve_original: bool = True) -> List[Dict[str, Any]]:
@@ -2525,22 +2276,22 @@ async def expand_nested_data(data: List[Dict[str, Any]], preserve_original: bool
     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
+        return [{"error": f"An unexpected error occurred: {str(e)}"}]
+        
+# --- Documentation Tool ---
 
 @mcp.tool()
-async def read_specific_documentation(page_id: str) -> Dict[str, Any]:
+async def get_documentation_page(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)
+        return await brain_client.get_documentation_page(page_id)
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
-# Badge status MCP tool removed as requested
+# --- Advanced Simulation Tools ---
 
 @mcp.tool()
-async def create_multiSim(
+async def create_multi_simulation(
     alpha_expressions: List[str],
     instrument_type: str = "EQUITY",
     region: str = "USA",
@@ -2622,7 +2373,7 @@ async def create_multiSim(
         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."}
+            return {"error": f"Failed to create multisimulation. Status: {response.status_code}"}
         
         # Get multisimulation location
         location = response.headers.get('Location', '')
@@ -2633,7 +2384,7 @@ async def create_multiSim(
         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."}
+        return {"error": f"Error creating multisimulation: {str(e)}"}
 
 async def _wait_for_multisimulation_completion(location: str, expected_children: int) -> Dict[str, Any]:
     """Wait for multisimulation to complete and return results"""
@@ -2748,12 +2499,12 @@ async def _wait_for_multisimulation_completion(location: str, 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."
+            'alpha_results': alpha_results
         }
         
     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."}
+        return {"error": f"Error waiting for multisimulation completion: {str(e)}"}
+# --- Payment and Financial Tools ---
 
 @mcp.tool()
 async def get_daily_and_quarterly_payment(email: str = "", password: str = "") -> Dict[str, Any]:
@@ -2771,74 +2522,41 @@ async def get_daily_and_quarterly_payment(email: str = "", password: str = "") -
         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()
+        config = load_config()
+        credentials = config.get("credentials", {})
+        email = email or credentials.get("email")
+        password = password or credentials.get("password")
+        if not email or not password:
+            return {"error": "Authentication credentials not provided or found in config."}
+            
+        await brain_client.authenticate(email, password)
         
-        # Return comprehensive payment information
+        # Get base payments
+        try:
+            base_response = brain_client.session.get(f"{brain_client.base_url}/users/self/activities/base-payment")
+            base_response.raise_for_status()
+            base_payments = base_response.json()
+        except:
+            base_payments = "no data"
+            
+        try:
+            # Get other payments
+            other_response = brain_client.session.get(f"{brain_client.base_url}/users/self/activities/other-payment")
+            other_response.raise_for_status()
+            other_payments = other_response.json()
+        except:
+            other_payments = "no data"    
         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()
+            "base_payments": base_payments,
+            "other_payments": other_payments
         }
         
     except Exception as e:
-        return {"error": f"Error retrieving payment information: {str(e)}"}
-
+        return {"error": f"An unexpected error occurred: {str(e)}"}
 
-
-# New MCP tool: get_SimError_detail
 from typing import Sequence
 @mcp.tool()
-async def get_SimError_detail(locations: Sequence[str]) -> dict:
+async def lookINTO_SimError_message(locations: Sequence[str]) -> dict:
     """
     Fetch and parse error/status from multiple simulation locations (URLs).
     Args:
@@ -2876,11 +2594,8 @@ async def get_SimError_detail(locations: Sequence[str]) -> dict:
             })
     return {"results": results}
 
+
+# --- Main entry point ---
 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)
-    
+    print("running the server")
+    mcp.run()