aigroup-econ-mcp 1.4.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

tools/mcp_tool_groups/microecon_tools.py

@@ -0,0 +1,325 @@
+"""
+微观计量模型工具组
+包含离散选择、计数数据和受限因变量模型的MCP工具
+"""
+
+from typing import List, Optional, Union, Dict, Any
+from mcp.server.fastmcp import Context
+from mcp.server.session import ServerSession
+
+from ..mcp_tools_registry import ToolGroup
+from ..microecon_adapter import (
+    logit_adapter,
+    probit_adapter,
+    multinomial_logit_adapter,
+    poisson_adapter,
+    negative_binomial_adapter,
+    tobit_adapter,
+    heckman_adapter
+)
+
+
+class MicroeconometricsTools(ToolGroup):
+    """微观计量模型工具组"""
+    
+    name = "MICROECONOMETRICS"
+    description = "微观计量模型工具"
+    version = "1.0.0"
+    
+    @classmethod
+    def get_tools(cls) -> List[Dict[str, Any]]:
+        """返回工具列表"""
+        return [
+            {
+                "name": "micro_logit",
+                "handler": cls.logit_tool,
+                "description": "Logistic Regression Model"
+            },
+            {
+                "name": "micro_probit",
+                "handler": cls.probit_tool,
+                "description": "Probit Regression Model"
+            },
+            {
+                "name": "micro_multinomial_logit",
+                "handler": cls.multinomial_logit_tool,
+                "description": "Multinomial Logit Model"
+            },
+            {
+                "name": "micro_poisson",
+                "handler": cls.poisson_tool,
+                "description": "Poisson Regression Model"
+            },
+            {
+                "name": "micro_negative_binomial",
+                "handler": cls.negative_binomial_tool,
+                "description": "Negative Binomial Regression Model"
+            },
+            {
+                "name": "micro_tobit",
+                "handler": cls.tobit_tool,
+                "description": "Tobit Model (Censored Regression)"
+            },
+            {
+                "name": "micro_heckman",
+                "handler": cls.heckman_tool,
+                "description": "Heckman Selection Model"
+            }
+        ]
+    
+    @classmethod
+    def get_help_text(cls) -> str:
+        """返回帮助文档"""
+        return """
+微观计量模型工具组 - 7种模型
+
+离散选择模型:
+1. Logit Model - micro_logit
+   - 二元Logistic回归
+   - 适用于二元因变量
+   
+2. Probit Model - micro_probit
+   - Probit回归
+   - 基于正态分布假设
+
+3. Multinomial Logit - micro_multinomial_logit
+   - 多项Logit模型
+   - 适用于多分类问题
+
+计数数据模型:
+4. Poisson Model - micro_poisson
+   - 泊松回归
+   - 适用于计数数据
+   
+5. Negative Binomial - micro_negative_binomial
+   - 负二项回归
+   - 处理过度离散问题
+
+受限因变量模型:
+6. Tobit Model - micro_tobit
+   - Tobit模型（截断回归）
+   - 适用于受限因变量
+   
+7. Heckman Model - micro_heckman
+   - Heckman样本选择模型
+   - 处理样本选择偏差
+"""
+    
+    @staticmethod
+    async def logit_tool(
+        X_data: Optional[List] = None,
+        y_data: Optional[List[int]] = None,
+        file_path: Optional[str] = None,
+        feature_names: Optional[List[str]] = None,
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """Logit回归分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Logit regression analysis...")
+            
+            result = logit_adapter(
+                X_data=X_data, y_data=y_data, file_path=file_path,
+                feature_names=feature_names, output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Logit analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def probit_tool(
+        X_data: Optional[List] = None,
+        y_data: Optional[List[int]] = None,
+        file_path: Optional[str] = None,
+        feature_names: Optional[List[str]] = None,
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """Probit回归分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Probit regression analysis...")
+            
+            result = probit_adapter(
+                X_data=X_data, y_data=y_data, file_path=file_path,
+                feature_names=feature_names, output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Probit analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def multinomial_logit_tool(
+        X_data: Optional[List] = None,
+        y_data: Optional[List[int]] = None,
+        file_path: Optional[str] = None,
+        feature_names: Optional[List[str]] = None,
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """多项Logit分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Multinomial Logit analysis...")
+            
+            result = multinomial_logit_adapter(
+                X_data=X_data, y_data=y_data, file_path=file_path,
+                feature_names=feature_names, output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Multinomial Logit analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def poisson_tool(
+        X_data: Optional[List] = None,
+        y_data: Optional[List[int]] = None,
+        file_path: Optional[str] = None,
+        feature_names: Optional[List[str]] = None,
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """泊松回归分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Poisson regression analysis...")
+            
+            result = poisson_adapter(
+                X_data=X_data, y_data=y_data, file_path=file_path,
+                feature_names=feature_names, output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Poisson analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def negative_binomial_tool(
+        X_data: Optional[List] = None,
+        y_data: Optional[List[int]] = None,
+        file_path: Optional[str] = None,
+        feature_names: Optional[List[str]] = None,
+        distr: str = 'nb2',
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """负二项回归分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Negative Binomial regression analysis...")
+            
+            result = negative_binomial_adapter(
+                X_data=X_data, y_data=y_data, file_path=file_path,
+                feature_names=feature_names, distr=distr,
+                output_format=output_format, save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Negative Binomial analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def tobit_tool(
+        X_data: Optional[List] = None,
+        y_data: Optional[List[float]] = None,
+        file_path: Optional[str] = None,
+        feature_names: Optional[List[str]] = None,
+        lower_bound: float = 0.0,
+        upper_bound: Optional[float] = None,
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """Tobit模型分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Tobit model analysis...")
+            
+            result = tobit_adapter(
+                X_data=X_data, y_data=y_data, file_path=file_path,
+                feature_names=feature_names, lower_bound=lower_bound,
+                upper_bound=upper_bound, output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Tobit analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def heckman_tool(
+        X_select_data: Optional[List] = None,
+        Z_data: Optional[List] = None,
+        y_data: Optional[List[float]] = None,
+        s_data: Optional[List[int]] = None,
+        file_path: Optional[str] = None,
+        selection_feature_names: Optional[List[str]] = None,
+        outcome_feature_names: Optional[List[str]] = None,
+        output_format: str = 'json',
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """Heckman样本选择模型分析"""
+        try:
+            if ctx:
+                await ctx.info("Starting Heckman selection model analysis...")
+            
+            result = heckman_adapter(
+                X_select_data=X_select_data, Z_data=Z_data,
+                y_data=y_data, s_data=s_data, file_path=file_path,
+                selection_feature_names=selection_feature_names,
+                outcome_feature_names=outcome_feature_names,
+                output_format=output_format, save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Heckman analysis complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise

tools/mcp_tool_groups/missing_data_tools.py

@@ -0,0 +1,117 @@
+"""
+缺失数据处理工具组
+"""
+
+from typing import List, Optional, Dict, Any
+from mcp.server.fastmcp import Context
+from mcp.server.session import ServerSession
+
+from ..mcp_tools_registry import ToolGroup
+from ..missing_data_adapter import (
+    simple_imputation_adapter,
+    multiple_imputation_adapter
+)
+
+
+class MissingDataTools(ToolGroup):
+    """缺失数据处理工具组"""
+    
+    name = "MISSING DATA HANDLING"
+    description = "缺失数据插补和处理工具"
+    version = "1.0.0"
+    
+    @classmethod
+    def get_tools(cls) -> List[Dict[str, Any]]:
+        """返回工具列表"""
+        return [
+            {
+                "name": "missing_data_simple_imputation",
+                "handler": cls.simple_imputation_tool,
+                "description": "Simple Imputation (Mean/Median/Mode/Constant)"
+            },
+            {
+                "name": "missing_data_multiple_imputation",
+                "handler": cls.multiple_imputation_tool,
+                "description": "Multiple Imputation (MICE)"
+            }
+        ]
+    
+    @classmethod
+    def get_help_text(cls) -> str:
+        return """
+缺失数据处理工具组 - 2个工具
+
+1. Simple Imputation (missing_data_simple_imputation)
+   - 简单插补方法
+   - 均值/中位数/众数/常数填充
+   - 基于: sklearn.impute
+   
+2. Multiple Imputation (missing_data_multiple_imputation)
+   - 多重插补 (MICE)
+   - 迭代插补算法
+   - 基于: sklearn.impute
+"""
+    
+    @staticmethod
+    async def simple_imputation_tool(
+        data: List[List[float]],
+        strategy: str = "mean",
+        fill_value: Optional[float] = None,
+        output_format: str = "json",
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """简单插补"""
+        try:
+            if ctx:
+                await ctx.info(f"Starting simple imputation ({strategy})...")
+            
+            result = simple_imputation_adapter(
+                data=data,
+                strategy=strategy,
+                fill_value=fill_value,
+                output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Simple imputation complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def multiple_imputation_tool(
+        data: List[List[float]],
+        n_imputations: int = 5,
+        max_iter: int = 10,
+        random_state: Optional[int] = None,
+        output_format: str = "json",
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """多重插补(MICE)"""
+        try:
+            if ctx:
+                await ctx.info(f"Starting multiple imputation (n={n_imputations})...")
+            
+            result = multiple_imputation_adapter(
+                data=data,
+                n_imputations=n_imputations,
+                max_iter=max_iter,
+                random_state=random_state,
+                output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Multiple imputation complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise

tools/mcp_tool_groups/nonparametric_tools.py

@@ -0,0 +1,225 @@
+"""
+非参数与半参数方法工具组
+包含核回归、分位数回归、样条回归和GAM
+"""
+
+from typing import List, Optional, Dict, Any
+from mcp.server.fastmcp import Context
+from mcp.server.session import ServerSession
+
+from ..mcp_tools_registry import ToolGroup
+from ..nonparametric_adapter import (
+    kernel_regression_adapter,
+    quantile_regression_adapter,
+    spline_regression_adapter,
+    gam_adapter
+)
+
+
+class NonparametricTools(ToolGroup):
+    """非参数与半参数方法工具组"""
+    
+    name = "NONPARAMETRIC & SEMIPARAMETRIC METHODS"
+    description = "非参数与半参数分析工具"
+    version = "1.0.0"
+    
+    @classmethod
+    def get_tools(cls) -> List[Dict[str, Any]]:
+        """返回工具列表"""
+        return [
+            {
+                "name": "nonparametric_kernel_regression",
+                "handler": cls.kernel_regression_tool,
+                "description": "Kernel Regression (Nonparametric)"
+            },
+            {
+                "name": "nonparametric_quantile_regression",
+                "handler": cls.quantile_regression_tool,
+                "description": "Quantile Regression"
+            },
+            {
+                "name": "nonparametric_spline_regression",
+                "handler": cls.spline_regression_tool,
+                "description": "Spline Regression"
+            },
+            {
+                "name": "nonparametric_gam_model",
+                "handler": cls.gam_tool,
+                "description": "Generalized Additive Model (GAM)"
+            }
+        ]
+    
+    @classmethod
+    def get_help_text(cls) -> str:
+        """返回帮助文档"""
+        return """
+非参数与半参数方法工具组 - 4个工具
+
+1. Kernel Regression (nonparametric_kernel_regression)
+   - 核回归估计
+   - 支持核函数: Gaussian, Epanechnikov, Uniform, Triangular, Biweight
+   - 带宽选择: 交叉验证, AIC, 正态参考
+   - 基于: statsmodels.nonparametric
+   
+2. Quantile Regression (nonparametric_quantile_regression)
+   - 分位数回归
+   - 分析条件分位数
+   - 稳健于异常值
+   - 基于: statsmodels.regression.quantile_regression
+
+3. Spline Regression (nonparametric_spline_regression)
+   - 样条回归
+   - 灵活的非线性拟合
+   - 基于: sklearn.preprocessing
+
+4. Generalized Additive Model (nonparametric_gam_model)
+   - 广义可加模型
+   - 多个平滑函数的加和
+   - 基于: pygam
+"""
+    
+    @staticmethod
+    async def kernel_regression_tool(
+        y_data: Optional[List[float]] = None,
+        x_data: Optional[List[List[float]]] = None,
+        file_path: Optional[str] = None,
+        kernel_type: str = "gaussian",
+        bandwidth: Optional[List[float]] = None,
+        bandwidth_method: str = "cv_ls",
+        variable_type: Optional[str] = None,
+        output_format: str = "json",
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """核回归分析"""
+        try:
+            if ctx:
+                await ctx.info(f"Starting kernel regression ({kernel_type} kernel)...")
+            
+            result = kernel_regression_adapter(
+                y_data=y_data,
+                x_data=x_data,
+                file_path=file_path,
+                kernel_type=kernel_type,
+                bandwidth=bandwidth,
+                bandwidth_method=bandwidth_method,
+                variable_type=variable_type,
+                output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Kernel regression complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def quantile_regression_tool(
+        y_data: Optional[List[float]] = None,
+        x_data: Optional[List[List[float]]] = None,
+        file_path: Optional[str] = None,
+        quantile: float = 0.5,
+        feature_names: Optional[List[str]] = None,
+        confidence_level: float = 0.95,
+        output_format: str = "json",
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """分位数回归分析"""
+        try:
+            if ctx:
+                await ctx.info(f"Starting quantile regression (τ={quantile})...")
+            
+            result = quantile_regression_adapter(
+                y_data=y_data,
+                x_data=x_data,
+                file_path=file_path,
+                quantile=quantile,
+                feature_names=feature_names,
+                confidence_level=confidence_level,
+                output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Quantile regression complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def spline_regression_tool(
+        y_data: List[float],
+        x_data: List[float],
+        n_knots: int = 5,
+        degree: int = 3,
+        knots: str = "uniform",
+        output_format: str = "json",
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """样条回归"""
+        try:
+            if ctx:
+                await ctx.info(f"Starting spline regression (degree={degree}, knots={n_knots})...")
+            
+            result = spline_regression_adapter(
+                y_data=y_data,
+                x_data=x_data,
+                n_knots=n_knots,
+                degree=degree,
+                knots=knots,
+                output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("Spline regression complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise
+    
+    @staticmethod
+    async def gam_tool(
+        y_data: List[float],
+        x_data: List[List[float]],
+        problem_type: str = "regression",
+        n_splines: int = 10,
+        lam: float = 0.6,
+        output_format: str = "json",
+        save_path: Optional[str] = None,
+        ctx: Context[ServerSession, None] = None
+    ) -> str:
+        """广义可加模型(GAM)"""
+        try:
+            if ctx:
+                await ctx.info(f"Starting GAM model ({problem_type})...")
+            
+            result = gam_adapter(
+                y_data=y_data,
+                x_data=x_data,
+                problem_type=problem_type,
+                n_splines=n_splines,
+                lam=lam,
+                output_format=output_format,
+                save_path=save_path
+            )
+            
+            if ctx:
+                await ctx.info("GAM model complete")
+            
+            return result
+        except Exception as e:
+            if ctx:
+                await ctx.error(f"Error: {str(e)}")
+            raise