agentic-kit-common 0.0.17__tar.gz → 0.0.21__tar.gz

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-kit-common
-Version: 0.0.17
+Version: 0.0.21
 Summary: Common utilities and tools for agentic kit ecosystem
 Home-page: 
 Author: manson
@@ -25,12 +25,14 @@ Requires-Dist: langgraph
 Requires-Dist: langchain_community
 Requires-Dist: langchain_experimental
 Requires-Dist: langchain-openai
+Requires-Dist: langchain_mcp_adapters
 Requires-Dist: mysql-connector-python
 Requires-Dist: sqlalchemy
 Requires-Dist: sqlglot
 Requires-Dist: pymilvus
 Requires-Dist: xinference_client
 Requires-Dist: pymongo
+Requires-Dist: redis
 Requires-Dist: aliyun-python-sdk-core
 Requires-Dist: aliyun-python-sdk-dysmsapi
 Dynamic: author

agentic_kit_common-0.0.21/agentic_kit_common/config/__init__.py

@@ -0,0 +1,21 @@
+from .config_loader import (
+    ConfigManager,
+    load_config,
+    get_llm_config,
+    get_rag_config,
+    get_database_config,
+    get_full_config,
+    reload_config,
+    set_config_manager,
+)
+
+__all__ = [
+    "ConfigManager",
+    "set_config_manager",
+    "load_config",
+    "get_llm_config",
+    "get_rag_config",
+    "get_database_config",
+    "get_full_config",
+    "reload_config",
+]

agentic_kit_common-0.0.21/agentic_kit_common/config/config_loader.py

@@ -0,0 +1,311 @@
+import logging
+import os
+from typing import Any, Dict, Optional
+
+import yaml
+from dotenv import load_dotenv, find_dotenv
+
+logger = logging.getLogger(__name__)
+
+
+load_dotenv(find_dotenv(usecwd=True))
+_config_root_path = os.getenv("DELTA_CONFIG_PATH", None)
+
+
+class ConfigManager:
+    """
+    配置管理器 - 支持多种配置源
+    
+    支持的配置方式（优先级从高到低）：
+    1. 环境变量（最高优先级）
+    2. 初始化时传入的 config 参数
+    3. 配置文件（config_path 或默认的 conf.yaml）
+    """
+    
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        config_path: Optional[str] = None
+    ):
+        """
+        初始化配置管理器
+        
+        Args:
+            config: 直接传入的配置字典（适合外部 SDK 调用）
+                格式示例：
+                {
+                    "BASIC_MODEL": {
+                        "base_url": "http://...",
+                        "model": "qwen",
+                        "api_key": "sk-xxx"
+                    },
+                    "VISION_MODEL": {
+                        "base_url": "http://...",
+                        "model": "vision",
+                        "api_key": "sk-xxx"
+                    },
+                    "RAG_CLIENT": {
+                        "base_url": "http://...",
+                        "timeout": 120
+                    },
+                    "DATABASE_CLIENT": {
+                        "base_url": "http://...",
+                        "timeout": 120
+                    },
+                    "MCP_SETTINGS": {
+                        "default_servers": {
+                            "file-processor": {
+                                "transport": "streamable_http",
+                                "url": "http://...",
+                                "enabled_tools": ["convert_to_markdown"]
+                            }
+                        }
+                    }
+                }
+            
+            config_path: 配置文件路径（可选）
+                - 如果不提供，默认使用项目根目录的 conf.yaml
+                - 如果提供，使用指定路径的配置文件
+        
+        Examples:
+            # 方式1: 直接传入配置（外部 SDK 推荐）
+            config_mgr = ConfigManager(config={
+                "BASIC_MODEL": {...},
+                "RAG_CLIENT": {...}
+            })
+            
+            # 方式2: 指定配置文件路径
+            config_mgr = ConfigManager(config_path="/path/to/conf.yaml")
+            
+            # 方式3: 使用默认配置文件（项目根目录/conf.yaml）
+            config_mgr = ConfigManager()
+        """
+        self._external_config = config or {}
+        self._config_path = config_path or _config_root_path
+        self._config_cache: Optional[Dict[str, Any]] = None
+    
+    def load_config(self, force_reload: bool = False) -> Dict[str, Any]:
+        """
+        加载配置（带缓存）
+        
+        Args:
+            force_reload: 是否强制重新加载
+            
+        Returns:
+            Dict[str, Any]: 完整配置字典
+        """
+        if self._config_cache is not None and not force_reload:
+            return self._config_cache
+        
+        # 如果有外部配置，直接使用
+        if self._external_config:
+            self._config_cache = self._external_config.copy()
+            logger.info("使用外部传入的配置")
+            return self._config_cache
+        
+        # 从配置文件加载
+        conf_path = self._config_path
+        
+        if not os.path.exists(conf_path):
+            logger.warning(f"配置文件不存在: {conf_path}，使用空配置")
+            self._config_cache = {}
+            return self._config_cache
+        
+        try:
+            with open(conf_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f) or {}
+            self._config_cache = config
+            logger.info(f"成功加载配置文件: {conf_path}")
+        except Exception as e:
+            logger.error(f"加载配置文件失败: {e}")
+            self._config_cache = {}
+        
+        return self._config_cache
+    
+    def get_llm_config(self, model_type: str = "BASIC_MODEL") -> Dict[str, Any]:
+        """
+        获取LLM配置
+        
+        Args:
+            model_type: 模型类型，可选 "BASIC_MODEL", "VISION_MODEL"
+            
+        Returns:
+            Dict[str, Any]: LLM配置
+        """
+        config = self.load_config()
+        base_config = config.get(model_type, {}).copy() if isinstance(config.get(model_type), dict) else {}
+        
+        # 环境变量覆盖（优先级最高）
+        prefix = f"{model_type}__"
+        for key, value in os.environ.items():
+            if key.startswith(prefix):
+                conf_key = key[len(prefix):].lower()
+                base_config[conf_key] = value
+        
+        return base_config
+    
+    def get_rag_config(self) -> Dict[str, Any]:
+        """
+        获取RAG客户端配置
+        
+        Returns:
+            Dict[str, Any]: RAG配置
+        """
+        config = self.load_config()
+        rag_config = config.get("RAG_CLIENT", {}).copy() if isinstance(config.get("RAG_CLIENT"), dict) else {}
+        
+        # 支持环境变量覆盖
+        env_overrides = {
+            "base_url": os.getenv("RAG_CLIENT__base_url"),
+            "timeout": os.getenv("RAG_CLIENT__timeout"),
+            "max_retries": os.getenv("RAG_CLIENT__max_retries"),
+        }
+        
+        for key, value in env_overrides.items():
+            if value is not None:
+                rag_config[key] = value
+        
+        return rag_config
+    
+    def get_mcp_config(self) -> Dict[str, Any]:
+        """
+        获取MCP服务器配置
+        
+        Returns:
+            Dict[str, Any]: MCP配置
+        """
+        config = self.load_config()
+        return config.get("MCP_SETTINGS", {})
+    
+    def get_database_config(self) -> Dict[str, Any]:
+        """
+        获取数据库客户端配置
+
+        Returns:
+            Dict[str, Any]: 数据库配置
+        """
+        config = self.load_config()
+        db_config = config.get("DATABASE_CLIENT", {}).copy() if isinstance(config.get("DATABASE_CLIENT"), dict) else {}
+
+        # 支持环境变量覆盖
+        env_overrides = {
+            "base_url": os.getenv("DATABASE_CLIENT__base_url"),
+            "timeout": os.getenv("DATABASE_CLIENT__timeout"),
+        }
+
+        for key, value in env_overrides.items():
+            if value is not None:
+                db_config[key] = value
+
+        return db_config
+    
+    def get_full_config(self) -> Dict[str, Any]:
+        """
+        获取完整配置
+        
+        Returns:
+            Dict[str, Any]: 完整配置字典
+        """
+        return self.load_config()
+    
+    def reload_config(self):
+        """重新加载配置（清除缓存）"""
+        self._config_cache = None
+        logger.info("配置已重新加载")
+
+
+# ============================================================================
+# 全局默认配置管理器（向后兼容）
+# ============================================================================
+
+_default_config_manager: Optional[ConfigManager] = None
+
+
+def _get_default_config_manager() -> ConfigManager:
+    """获取默认配置管理器实例"""
+    global _default_config_manager
+    if _default_config_manager is None:
+        _default_config_manager = ConfigManager()
+    return _default_config_manager
+
+
+def set_config_manager(config_manager: ConfigManager):
+    """
+    设置全局配置管理器（用于外部 SDK）
+    
+    Args:
+        config_manager: ConfigManager 实例
+        
+    Example:
+        # 在外部 SDK 中设置自定义配置
+        config_mgr = ConfigManager(config={...})
+        set_config_manager(config_mgr)
+    """
+    global _default_config_manager
+    _default_config_manager = config_manager
+    logger.info("已设置全局配置管理器")
+
+
+# ============================================================================
+# 向后兼容的函数接口
+# ============================================================================
+
+def load_config(force_reload: bool = False) -> Dict[str, Any]:
+    """
+    加载配置文件（带缓存）
+    
+    Args:
+        force_reload: 是否强制重新加载
+        
+    Returns:
+        Dict[str, Any]: 完整配置字典
+    """
+    return _get_default_config_manager().load_config(force_reload)
+
+
+def get_llm_config(model_type: str = "BASIC_MODEL") -> Dict[str, Any]:
+    """
+    获取LLM配置
+    
+    Args:
+        model_type: 模型类型，可选 "BASIC_MODEL", "VISION_MODEL"
+        
+    Returns:
+        Dict[str, Any]: LLM配置
+    """
+    return _get_default_config_manager().get_llm_config(model_type)
+
+
+def get_rag_config() -> Dict[str, Any]:
+    """
+    获取RAG客户端配置
+    
+    Returns:
+        Dict[str, Any]: RAG配置
+    """
+    return _get_default_config_manager().get_rag_config()
+
+
+def get_database_config() -> Dict[str, Any]:
+    """
+    获取数据库客户端配置
+
+    Returns:
+        Dict[str, Any]: 数据库配置
+    """
+    return _get_default_config_manager().get_database_config()
+
+
+def get_full_config() -> Dict[str, Any]:
+    """
+    获取完整配置
+    
+    Returns:
+        Dict[str, Any]: 完整配置字典
+    """
+    return _get_default_config_manager().get_full_config()
+
+
+def reload_config():
+    """重新加载配置（清除缓存）"""
+    _get_default_config_manager().reload_config()

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common/llm/openai.py

@@ -1,9 +1,9 @@
 import os
 
-from dotenv import load_dotenv
+from dotenv import load_dotenv, find_dotenv
 from langchain_openai import ChatOpenAI
 
-load_dotenv()
+load_dotenv(find_dotenv(usecwd=True))
 
 
 model_name = os.getenv("MODEL_NAME", None)

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common/log/logger.py

@@ -5,9 +5,9 @@ from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
 from typing import Union
 
-from dotenv import load_dotenv
+from dotenv import load_dotenv, find_dotenv
 
-load_dotenv()
+load_dotenv(find_dotenv(usecwd=True))
 
 
 logger_root_path = os.getenv("LOGGER_ROOT_PATH", None)

agentic_kit_common-0.0.21/agentic_kit_common/mcp/mcp_client.py

@@ -0,0 +1,344 @@
+import logging
+from typing import Dict, Any, List, Optional, TYPE_CHECKING
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_core.tools import BaseTool
+
+# if TYPE_CHECKING:
+#     from src.core.config import ConfigManager
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+
+class MCPToolsNotAvailableError(Exception):
+    """MCP工具不可用异常"""
+    pass
+
+
+class MCPClient:
+    """
+    MCP (Model Context Protocol) 客户端
+    
+    支持的配置方式（优先级从高到低）：
+    1. 初始化时传入的 config 参数
+    2. 配置管理器 (config_manager)
+    3. 默认配置文件（项目根目录/conf.yaml）
+    
+    Examples:
+        # 方式1: 直接传入配置（外部 SDK 推荐）
+        client = MCPClient(config={
+            "default_servers": {
+                "web_search": {
+                    "url": "http://your-server.com/mcp",
+                    "transport": "streamable_http",
+                    "enabled_tools": ["web_search", "crawl_page"]  # 可选，不传则使用所有工具
+                }
+            }
+        })
+        
+        # 方式2: 使用配置管理器
+        from src.core.config import ConfigManager
+        config_mgr = ConfigManager(config={
+            "MCP_SETTINGS": {
+                "default_servers": {...}
+            }
+        })
+        client = MCPClient(config_manager=config_mgr)
+        
+        # 方式3: 使用默认配置文件（conf.yaml）
+        client = MCPClient()
+    """
+    
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        config_manager: Optional['ConfigManager'] = None
+    ):
+        """
+        初始化MCP客户端
+        
+        Args:
+            config: 直接传入的配置字典（可选）
+                格式示例：
+                {
+                    "default_servers": {
+                        "server_name": {
+                            "url": "http://...",
+                            "transport": "sse" | "streamable_http",
+                            "enabled_tools": ["tool1", "tool2"]  # 可选，不传则使用所有工具
+                        }
+                    }
+                }
+            config_manager: 配置管理器实例（可选）
+        """
+        assert not (config is None and config_manager is None), "config 与 config_manager 不能同时为 None"
+
+        self._config = config
+        self._config_manager = config_manager
+        self._client: Optional[MultiServerMCPClient] = None
+        self._initialized = False
+        self._enabled_tools_map: Dict[str, List[str]] = {}  # 服务器名 -> 启用的工具列表
+        self._server_tools_cache: Dict[str, List[BaseTool]] = {}  # 服务器名 -> 工具列表缓存
+    
+    def _get_mcp_config(self) -> Dict[str, Any]:
+        """
+        获取 MCP 配置
+        
+        Returns:
+            Dict[str, Any]: MCP 配置
+        """
+        if self._config:
+            return self._config
+        
+        if self._config_manager:
+            return self._config_manager.get_mcp_config()
+    
+    async def initialize(self):
+        """初始化MCP客户端"""
+        if self._initialized:
+            return
+        
+        try:
+            mcp_config = self._get_mcp_config()
+            default_servers = mcp_config.get('default_servers', {})
+            
+            if not default_servers:
+                logger.warning("配置文件中没有MCP服务器")
+                return
+            
+            logger.info(f"开始初始化 {len(default_servers)} 个MCP服务器...")
+            
+            server_configs = {}
+            for server_name, server_config in default_servers.items():
+                url = server_config.get('url')
+                transport = server_config.get('transport', 'sse')
+                enabled_tools = server_config.get('enabled_tools')
+                
+                if not url:
+                    logger.warning(f"服务器 {server_name} 缺少URL配置")
+                    continue
+                
+                server_configs[server_name] = {
+                    'url': url,
+                    'transport': transport
+                }
+                
+                if enabled_tools:
+                    self._enabled_tools_map[server_name] = enabled_tools
+                    logger.info(f"服务器 {server_name} 启用工具: {enabled_tools}")
+                else:
+                    logger.info(f"服务器 {server_name} 将使用所有可用工具")
+            
+            if not server_configs:
+                logger.warning("没有有效的MCP服务器配置")
+                return
+            
+            self._client = MultiServerMCPClient(server_configs)
+            
+            self._initialized = True
+            
+            tools = await self.get_all_tools()
+            logger.info(f"成功初始化MCP客户端，加载了 {len(tools)} 个工具")
+            
+        except Exception as e:
+            logger.error(f"MCP客户端初始化失败: {str(e)}", exc_info=True)
+            raise MCPToolsNotAvailableError(f"初始化失败: {str(e)}") from e
+    
+    async def get_all_tools(self) -> List[BaseTool]:
+        """
+        获取所有MCP工具
+        
+        如果配置了 enabled_tools，只返回启用的工具；
+        否则返回所有可用工具。
+        
+        Returns:
+            List[BaseTool]: 所有可用工具的列表（LangChain工具）
+        """
+        if not self._initialized:
+            await self.initialize()
+        
+        if not self._client:
+            logger.warning("MCP客户端未初始化")
+            return []
+        
+        try:
+            all_tools = await self._client.get_tools()
+            
+            if not self._enabled_tools_map:
+                logger.debug(f"获取到 {len(all_tools)} 个MCP工具（使用所有工具）")
+                return all_tools
+            
+            enabled_tools = []
+            all_enabled_tool_names = set()
+            
+            for server_name, tool_names in self._enabled_tools_map.items():
+                all_enabled_tool_names.update(tool_names)
+            
+            for tool in all_tools:
+                if tool.name in all_enabled_tool_names:
+                    enabled_tools.append(tool)
+            
+            logger.info(f"获取到 {len(all_tools)} 个MCP工具，启用了 {len(enabled_tools)} 个工具")
+            if len(enabled_tools) < len(all_enabled_tool_names):
+                missing_tools = all_enabled_tool_names - {t.name for t in enabled_tools}
+                logger.warning(f"配置中的某些工具未找到: {missing_tools}")
+            
+            return enabled_tools
+            
+        except Exception as e:
+            logger.error(f"获取MCP工具失败: {str(e)}", exc_info=True)
+            return []
+
+    async def get_tool_by_name(self, tool_name: str) -> Optional[BaseTool]:
+        """
+        根据名称获取特定工具
+        
+        Args:
+            tool_name: 工具名称
+            
+        Returns:
+            工具实例，如果未找到返回None
+        """
+        tools = await self.get_all_tools()
+        for tool in tools:
+            if tool.name == tool_name:
+                return tool
+        return None
+    
+    async def get_tools_by_server(self, server_names: str | List[str]) -> List[BaseTool]:
+        """
+        根据服务器名称获取工具（支持单个或多个服务器）
+        
+        Args:
+            server_names: 服务器名称或服务器名称列表
+            
+        Returns:
+            List[BaseTool]: 工具列表（如果是多个服务器，会合并去重）
+            
+        Examples:
+            # 获取单个服务器的工具
+            tools = await mcp_client.get_tools_by_server("web_search_server")
+            
+            # 获取多个服务器的工具
+            tools = await mcp_client.get_tools_by_server(["web_search_server", "file-processor"])
+            
+            # 也支持传入逗号分隔的字符串
+            tools = await mcp_client.get_tools_by_server("web_search_server,file-processor")
+        """
+        if not self._initialized:
+            await self.initialize()
+        
+        if not self._client:
+            logger.warning("MCP客户端未初始化")
+            return []
+        
+        # 统一处理输入格式
+        if isinstance(server_names, str):
+            # 支持逗号分隔的字符串
+            if ',' in server_names:
+                server_list = [s.strip() for s in server_names.split(',') if s.strip()]
+            else:
+                server_list = [server_names]
+        else:
+            server_list = server_names
+        
+        if not server_list:
+            logger.warning("未提供有效的服务器名称")
+            return []
+        
+        # 收集所有工具（去重）
+        all_server_tools = []
+        seen_tool_names = set()
+        
+        for server_name in server_list:
+            # 检查缓存
+            if server_name in self._server_tools_cache:
+                logger.debug(f"使用缓存的服务器工具: {server_name}")
+                server_tools = self._server_tools_cache[server_name]
+            else:
+                # 获取该服务器的工具
+                server_tools = await self._get_single_server_tools(server_name)
+                # 缓存结果
+                self._server_tools_cache[server_name] = server_tools
+            
+            # 添加到结果中（去重）
+            for tool in server_tools:
+                if tool.name not in seen_tool_names:
+                    all_server_tools.append(tool)
+                    seen_tool_names.add(tool.name)
+        
+        if len(server_list) == 1:
+            logger.info(f"服务器 {server_list[0]} 有 {len(all_server_tools)} 个工具")
+        else:
+            logger.info(f"从 {len(server_list)} 个服务器获取了 {len(all_server_tools)} 个工具（已去重）")
+        
+        return all_server_tools
+    
+    async def _get_single_server_tools(self, server_name: str) -> List[BaseTool]:
+        """
+        获取单个服务器的工具（内部方法）
+        
+        Args:
+            server_name: 服务器名称
+            
+        Returns:
+            List[BaseTool]: 该服务器的工具列表
+        """
+        try:
+            all_tools = await self._client.get_tools()
+            server_tools = []
+            
+            for tool in all_tools:
+                # 方式1: 检查 tool.server 属性
+                if hasattr(tool, 'server') and tool.server == server_name:
+                    server_tools.append(tool)
+                # 方式2: 检查 tool.metadata
+                elif hasattr(tool, 'metadata') and tool.metadata is not None and tool.metadata.get('server') == server_name:
+                    server_tools.append(tool)
+                # 方式3: 检查 enabled_tools_map 配置
+                elif server_name in self._enabled_tools_map:
+                    if tool.name in self._enabled_tools_map[server_name]:
+                        server_tools.append(tool)
+            
+            # 如果前面的方式都没找到，但配置了 enabled_tools，尝试按工具名匹配
+            if not server_tools and server_name in self._enabled_tools_map:
+                enabled_tool_names = self._enabled_tools_map[server_name]
+                server_tools = [
+                    tool for tool in all_tools 
+                    if tool.name in enabled_tool_names
+                ]
+            
+            logger.debug(f"服务器 {server_name} 有 {len(server_tools)} 个工具")
+            return server_tools
+            
+        except Exception as e:
+            logger.error(f"获取服务器 {server_name} 的工具失败: {str(e)}", exc_info=True)
+            return []
+    
+    async def list_servers(self) -> List[str]:
+        """
+        列出所有配置的服务器名称
+        
+        Returns:
+            List[str]: 服务器名称列表
+            
+        Examples:
+            servers = await mcp_client.list_servers()
+            print(f"已配置的服务器: {servers}")
+        """
+        mcp_config = self._get_mcp_config()
+        default_servers = mcp_config.get('default_servers', {})
+        return list(default_servers.keys())
+    
+    def close(self):
+        """
+        清理 MCP 客户端
+        """
+        if self._client and self._initialized:
+            self._initialized = False
+            self._client = None
+            self._server_tools_cache.clear()
+            logger.info("MCP客户端已清理")
+
+# mcp_client = MCPClient()

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common/orm/session.py

@@ -1,12 +1,12 @@
 import asyncio
 import os
 from contextlib import contextmanager
-from dotenv import load_dotenv
+from dotenv import load_dotenv, find_dotenv
 from sqlalchemy import create_engine, text
 from sqlalchemy.exc import OperationalError
 from sqlalchemy.orm import sessionmaker, scoped_session
 
-load_dotenv()
+load_dotenv(find_dotenv(usecwd=True))
 
 
 sqlalchemy_database_uri = os.getenv("SQLALCHEMY_DATABASE_URI", "sqlite:///fallback.db")

agentic_kit_common-0.0.21/agentic_kit_common/redis/redis_pool_manager.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Dict
+
+from redis.asyncio import ConnectionPool, Redis
+
+
+class RedisPoolManager:
+    """
+    单例，负责：
+    1. 持有全局 ConnectionPool
+    2. 记录 client_id -> Redis 实例
+    3. 生命周期内统一创建/销毁
+    """
+    _inst: RedisPoolManager | None = None
+    _lock = asyncio.Lock()
+
+    def __new__(cls, *a, **kw):
+        if cls._inst is None:
+            cls._inst = super().__new__(cls)
+        return cls._inst
+
+    def __init__(
+        self,
+        redis_url: str = "redis://localhost:6379/0",
+        max_connections: int = 256,
+    ):
+        # 只允许初始化一次
+        if hasattr(self, "_init"):
+            return
+        self.redis_url = redis_url
+        self.max_connections = max_connections
+        self._pool: ConnectionPool | None = None
+        self._clients: Dict[str, Redis] = {}
+        self._init = True
+
+    async def ensure_pool(self):
+        """延迟创建pool"""
+        if self._pool is None:
+            self._pool = ConnectionPool.from_url(
+                self.redis_url,
+                max_connections=self.max_connections,
+                decode_responses=True,  # 直接 str，免手动 decode
+            )
+
+    async def startup(self):
+        """FastAPI startup 事件回调"""
+        await self.ensure_pool()
+
+    async def shutdown(self):
+        """FastAPI shutdown 事件回调"""
+        async with self._lock:
+            # 1. 关闭所有客户端
+            await asyncio.gather(*(c.aclose() for c in self._clients.values()))
+
+            self._clients.clear()
+            # 2. 关闭连接池
+            if self._pool:
+                await self._pool.aclose()
+                self._pool = None
+
+    async def get_client(self, client_id: str) -> Redis:
+        """线程安全地获取（或创建）一个 Redis 实例，复用同一池"""
+        async with self._lock:
+            if client_id in self._clients:
+                return self._clients[client_id]
+            await self.ensure_pool()
+            redis = Redis.from_pool(connection_pool=self._pool)
+            self._clients[client_id] = redis
+            return redis
+
+    async def close_client(self, client_id: str) -> bool:
+        """线程安全地关闭一个 Redis 实例"""
+        async with self._lock:
+            if client_id in self._clients:
+                await self._clients[client_id].aclose()
+                await self._clients.pop(client_id)
+                return True
+            return False
+
+    async def list_clients(self) -> None:
+        """线程安全地关闭一个 Redis 实例"""
+        async with self._lock:
+            clients = [c for c in self._clients.values()]
+            print(f'共{len(clients)}个client')
+
+    async def __aenter__(self):
+        """异步上下文管理器入口"""
+        await self.startup()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """异步上下文管理器出口"""
+        await self.shutdown()
+
+
+if __name__ == '__main__':
+    global_redis_pool_manager = RedisPoolManager()
+
+    async def _main():
+        client = await global_redis_pool_manager.get_client(client_id='test_1234')
+        await global_redis_pool_manager.list_clients()
+
+        await client.set('k1', 'hello', ex=3)  # 设值 + 30 秒过期
+        val = await client.get('k1')
+        print(f'get redis cache: {val}')
+
+        time.sleep(3)
+
+        val = await client.get('k1')
+        print(f'get redis cache: {val}')
+
+        await global_redis_pool_manager.close_client(client_id='test_1234')
+        await global_redis_pool_manager.list_clients()
+
+    asyncio.run(_main())

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common/sms/ali_sms_client.py

@@ -1,11 +1,11 @@
 from aliyunsdkcore.client import AcsClient
 from aliyunsdkcore.request import CommonRequest
-from dotenv import load_dotenv
+from dotenv import load_dotenv, find_dotenv
 from pydantic import Field
 from pydantic_settings import BaseSettings
 
 
-load_dotenv()
+load_dotenv(find_dotenv(usecwd=True))
 
 
 class SmsSettings(BaseSettings):

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-kit-common
-Version: 0.0.17
+Version: 0.0.21
 Summary: Common utilities and tools for agentic kit ecosystem
 Home-page: 
 Author: manson
@@ -25,12 +25,14 @@ Requires-Dist: langgraph
 Requires-Dist: langchain_community
 Requires-Dist: langchain_experimental
 Requires-Dist: langchain-openai
+Requires-Dist: langchain_mcp_adapters
 Requires-Dist: mysql-connector-python
 Requires-Dist: sqlalchemy
 Requires-Dist: sqlglot
 Requires-Dist: pymilvus
 Requires-Dist: xinference_client
 Requires-Dist: pymongo
+Requires-Dist: redis
 Requires-Dist: aliyun-python-sdk-core
 Requires-Dist: aliyun-python-sdk-dysmsapi
 Dynamic: author

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common.egg-info/SOURCES.txt

@@ -6,11 +6,15 @@ agentic_kit_common.egg-info/SOURCES.txt
 agentic_kit_common.egg-info/dependency_links.txt
 agentic_kit_common.egg-info/requires.txt
 agentic_kit_common.egg-info/top_level.txt
+agentic_kit_common/config/__init__.py
+agentic_kit_common/config/config_loader.py
 agentic_kit_common/llm/__init__.py
 agentic_kit_common/llm/openai.py
 agentic_kit_common/llm/utils.py
 agentic_kit_common/log/__init__.py
 agentic_kit_common/log/logger.py
+agentic_kit_common/mcp/__init__.py
+agentic_kit_common/mcp/mcp_client.py
 agentic_kit_common/minio/__init__.py
 agentic_kit_common/minio/minio_manager.py
 agentic_kit_common/mongodb/__init__.py
@@ -22,6 +26,8 @@ agentic_kit_common/orm/manager.py
 agentic_kit_common/orm/multi_session.py
 agentic_kit_common/orm/schema.py
 agentic_kit_common/orm/session.py
+agentic_kit_common/redis/__init__.py
+agentic_kit_common/redis/redis_pool_manager.py
 agentic_kit_common/sms/__init__.py
 agentic_kit_common/sms/ali_sms_client.py
 agentic_kit_common/vector/__init__.py
@@ -36,9 +42,12 @@ agentic_kit_common/web/__init__.py
 agentic_kit_common/web/http/__init__.py
 agentic_kit_common/web/http/response.py
 test/__init__.py
+test/conf.yaml
 test/config.py
 test/settings.py
+test/test_config_manager.py
 test/test_embedding.py
+test/test_mcp_client.py
 test/test_minio.py
 test/test_orm.py
 test/test_vector.py

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/agentic_kit_common.egg-info/requires.txt

@@ -7,11 +7,13 @@ langgraph
 langchain_community
 langchain_experimental
 langchain-openai
+langchain_mcp_adapters
 mysql-connector-python
 sqlalchemy
 sqlglot
 pymilvus
 xinference_client
 pymongo
+redis
 aliyun-python-sdk-core
 aliyun-python-sdk-dysmsapi

{agentic_kit_common-0.0.17 → agentic_kit_common-0.0.21}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='agentic-kit-common',
-    version="0.0.17",
+    version="0.0.21",
     author="manson",
     author_email="manson.li3307@gmail.com",
     description='Common utilities and tools for agentic kit ecosystem',
@@ -38,6 +38,7 @@ setup(
         "langchain_community",
         "langchain_experimental",
         "langchain-openai",
+        "langchain_mcp_adapters",
 
         # sqlalchemy
         "mysql-connector-python",
@@ -55,6 +56,9 @@ setup(
         # mongodb
         "pymongo",
 
+        # redis
+        "redis",
+
         # aliyun sms
         "aliyun-python-sdk-core",
         "aliyun-python-sdk-dysmsapi",

agentic_kit_common-0.0.21/test/conf.yaml

@@ -0,0 +1,56 @@
+BASIC_MODEL:
+  default: qwen3-235b-a22b
+  models:
+    qwen3-235b-a22b:
+      base_url: http://45.120.102.120:8990/v1
+      model: /mnt/data0/hf_models/models/Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
+      api_key: YOUR_API_KEY
+      temperature: 0.1
+    
+VISION_MODEL:
+  default: qwen3-vl-235b-instruct
+  models:
+    qwen3-vl-235b-instruct:
+      base_url: http://45.120.102.120:10021/v1
+      model: Qwen3-VL-235B-A22B-Instruct-FP8
+      api_key: YOUR_API_KEY
+      temperature: 0.1
+    
+    llm_ocr:
+      base_url: https://dashscope.aliyuncs.com/compatible-mode/v1
+      model: qwen-vl-ocr-latest
+      api_key: sk-c254cefb0b60414aa9a9686459c05602
+      temperature: 0.1
+
+
+# RAG 客户端配置
+RAG_CLIENT:
+  base_url: http://45.120.102.233:8900
+  timeout: 120
+
+# NL2SQL 数据库查询配置
+DATABASE_CLIENT:
+  base_url: http://45.120.102.233:8991
+  timeout: 30
+
+
+# MCP 服务器配置
+MCP_SETTINGS:
+  default_servers:
+    file-processor:
+      transport: streamable_http
+      url: http://45.120.102.231:8920/mcp
+      enabled_tools:
+        - convert_to_markdown
+    
+    web_search_server:
+      transport: streamable_http
+      url: http://45.120.102.231:8910/mcp
+      enabled_tools:
+        - web_search
+    
+    crawl_page_server:
+      transport: streamable_http
+      url: http://45.120.102.231:8926/mcp
+      enabled_tools:
+        - crawl_page

agentic_kit_common-0.0.21/test/test_config_manager.py

@@ -0,0 +1,29 @@
+import logging
+import sys
+import unittest
+from pathlib import Path
+
+
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+logging.basicConfig(level=logging.DEBUG)
+
+from agentic_kit_common.config import ConfigManager
+
+
+class MyTestCase(unittest.TestCase):
+    def test_config_manager(self):
+        config_manager = ConfigManager()
+        config_manager.load_config(force_reload=True)
+
+        print(config_manager.get_llm_config())
+        print(config_manager.get_llm_config(model_type='VISION_MODEL'))
+        print(config_manager.get_rag_config())
+        print(config_manager.get_mcp_config())
+        print(config_manager.get_database_config())
+        print(config_manager.get_full_config())
+
+
+if __name__ == '__main__':
+    unittest.main()

agentic_kit_common-0.0.21/test/test_mcp_client.py

@@ -0,0 +1,29 @@
+import asyncio
+import logging
+import sys
+import unittest
+from pathlib import Path
+
+from agentic_kit_common.mcp.mcp_client import MCPClient
+
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+logging.basicConfig(level=logging.DEBUG)
+
+from agentic_kit_common.config import ConfigManager
+
+
+class MyTestCase(unittest.TestCase):
+    def test_mcp_client(self):
+        config_manager = ConfigManager()
+        config_manager.load_config(force_reload=True)
+
+        mcp_client = MCPClient(config_manager=config_manager)
+        mcp_client.initialize()
+        print(asyncio.run(mcp_client.list_servers()))
+        print(asyncio.run(mcp_client.get_all_tools()))
+
+
+if __name__ == '__main__':
+    unittest.main()