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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-kit-common
-Version: 0.0.11
+Version: 0.0.17
 Summary: Common utilities and tools for agentic kit ecosystem
 Home-page: 
 Author: manson
@@ -24,11 +24,15 @@ Requires-Dist: langchain_core
 Requires-Dist: langgraph
 Requires-Dist: langchain_community
 Requires-Dist: langchain_experimental
+Requires-Dist: langchain-openai
 Requires-Dist: mysql-connector-python
 Requires-Dist: sqlalchemy
 Requires-Dist: sqlglot
 Requires-Dist: pymilvus
 Requires-Dist: xinference_client
+Requires-Dist: pymongo
+Requires-Dist: aliyun-python-sdk-core
+Requires-Dist: aliyun-python-sdk-dysmsapi
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

agentic_kit_common-0.0.17/agentic_kit_common/llm/__init__.py

@@ -0,0 +1,2 @@
+from .openai import create_openai_llm
+from .utils import combine_simple_context

agentic_kit_common-0.0.17/agentic_kit_common/llm/openai.py

@@ -0,0 +1,33 @@
+import os
+
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+
+load_dotenv()
+
+
+model_name = os.getenv("MODEL_NAME", None)
+openai_api_base = os.getenv("OPENAI_API_BASE", None)
+openai_api_key = os.getenv("OPENAI_API_KEY", 'API_KEY')
+temperature = float(os.getenv("TEMPERATURE", 0.2))
+
+
+def create_openai_llm(**kwargs):
+    _model_name = kwargs.pop('model_name', model_name)
+    _openai_api_base = kwargs.pop('openai_api_base', openai_api_base)
+    _openai_api_key = kwargs.pop('openai_api_key', openai_api_key)
+    if not _openai_api_key:
+        _openai_api_key = 'API_KEY'
+    _temperature = kwargs.pop('temperature', temperature)
+
+    assert model_name is not None
+    assert openai_api_base is not None
+
+    llm = ChatOpenAI(
+        model_name=_model_name,
+        openai_api_base=_openai_api_base,
+        openai_api_key=_openai_api_key,
+        temperature=_temperature,
+        **kwargs
+    )
+    return llm

agentic_kit_common-0.0.17/agentic_kit_common/llm/utils.py

@@ -0,0 +1,61 @@
+import json
+import re
+from typing import Any, Dict, List, Union
+
+from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
+
+
+def combine_simple_context(system: str, user: str = None):
+    context: List[Union[BaseMessage, dict[str, Any]]] = [SystemMessage(content=system)]
+    if user:
+        context.append(HumanMessage(content=system))
+    return context
+
+
+def fix_json_response(text: str) -> Union[Dict, List, str, int, float, bool, None]:
+    """
+    去掉大模型返回的 ```json / ``` 等 markdown 标记，并安全反序列化 JSON。
+    若解析失败，返回原字符串。
+
+    参数
+    ----
+    text : str
+        原始响应，可能包含 ```json ... ``` 或其他变体。
+
+    返回
+    ----
+    Python 对象（dict / list / str / int / float / bool / None）
+        解析失败时返回输入字符串本身。
+    """
+    if not isinstance(text, str):
+        return text
+
+    # 1. 去掉 ```json 或 ``` 包裹（支持开头、结尾、单行、多行）
+    cleaned = re.sub(r'^\s*```(?:json|JSON)?\s*\n?', '', text)
+    cleaned = re.sub(r'\n?\s*```\s*$', '', cleaned)
+
+    # 2. 去掉首尾空白
+    cleaned = cleaned.strip()
+
+    # 3. 尝试 JSON 反序列化
+    try:
+        json.loads(cleaned)
+        return cleaned
+    except json.JSONDecodeError:
+        # 4. 兜底：返回原字符串
+        return text
+
+
+# ----------------- 使用示例 -----------------
+if __name__ == "__main__":
+    demo_list = [
+        '```json\n{"a": 1, "b": "hello"}\n```',
+        "```JSON{'key': 'value'}```",
+        "```\n[1, 2, 3]```",
+        "plain text",
+        {"already_dict": 1},
+    ]
+    for d in demo_list:
+        print("原始:", repr(d))
+        print("修复:", repr(fix_json_response(d)))
+        print("-" * 30)

agentic_kit_common-0.0.17/agentic_kit_common/log/logger.py

@@ -0,0 +1,69 @@
+import logging
+import os
+import uuid
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+from typing import Union
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+logger_root_path = os.getenv("LOGGER_ROOT_PATH", None)
+log_dir = None
+
+if logger_root_path:
+    if logger_root_path.endswith('/'):
+        log_dir = f"{logger_root_path}logs"
+    else:
+        log_dir = f"{logger_root_path}/logs"
+    Path(log_dir).mkdir(parents=True, exist_ok=True)
+
+
+class LogUtils:
+    _handlers = {}
+
+    # 日志文件根据日期创建
+    # 根据参数name，将message写入对应的日志文件内
+    @classmethod
+    def log(cls, name: str="log", message: str="", log_uuid: str = str(uuid.uuid4()), level: Union[int, str] = logging.INFO) -> None:
+        if not log_dir:
+            return
+
+        try:
+            logger = logging.getLogger(name)
+            logger.setLevel(level)
+            logger.propagate = False
+            if name not in cls._handlers:
+                # 保证日志文件存在
+                # LOG_DIR.mkdir(parents=True, exist_ok=True)
+                # print(f"Log directory created at: {LOG_DIR}")
+                handler = TimedRotatingFileHandler(f'{log_dir}/{name}.log',  # 基础文件名
+                            when='midnight',  # 每天午夜
+                            interval=1,
+                            backupCount=7,  # 保留7天
+                            encoding='utf-8'
+                        )
+                formatter = logging.Formatter('%(uuid)s - %(asctime)s - %(name)s - %(levelname)s - %(message)s')
+                handler.setFormatter(formatter)
+                handler.setLevel(level)
+
+                # 控制台日志
+                stream_handler = logging.StreamHandler()
+                stream_handler.setLevel(level)
+                stream_formatter = logging.Formatter('%(uuid)s - %(asctime)s - %(name)s - %(levelname)s - %(message)s')
+                stream_handler.setFormatter(stream_formatter)
+                if not logger.hasHandlers():
+                    logger.addHandler(handler)
+                    logger.addHandler(stream_handler)
+                cls._handlers[name] = handler
+
+            req_id =  log_uuid or str(uuid.uuid4())
+            logger.log(level, message, extra={'uuid': req_id})  # 使用UUID
+
+            for handler in logger.handlers:
+                handler.flush()
+        except Exception as e:
+            # note: ignore error
+            pass

agentic_kit_common-0.0.17/agentic_kit_common/mongodb/__init__.py

@@ -0,0 +1,2 @@
+from .mongodb_manager import MongodbConfig
+from .mongodb_manager import MongodbManager

agentic_kit_common-0.0.17/agentic_kit_common/mongodb/mongodb_manager.py

@@ -0,0 +1,294 @@
+import logging
+from typing import Any, List, Dict, Optional, Tuple
+
+from pydantic import BaseModel, Field
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from pymongo.database import Database
+from pymongo.errors import PyMongoError, AutoReconnect
+
+
+class MongodbConfig(BaseModel):
+    """
+    Config for mongodb.
+    """
+
+    host: str = Field(..., description="MongoDB服务器地址")
+    port: Optional[int] = Field(27017, description="MongoDB服务器端口")
+    database: Optional[str] = Field('default', description="数据库名称")
+    collection_name: Optional[str] = Field('default', description="集合名称")
+
+    username: Optional[str] = Field(None, description="MongoDB用户名")
+    password: Optional[str] = Field(None, description="MongoDB密码")
+    ssl: Optional[bool] = Field(False, description="是否使用SSL连接")
+
+    max_pool_size: Optional[int] = Field(20, description="最大连接池大小")
+    min_pool_size: Optional[int] = Field(5, description="最小连接池大小")
+    wait_queue_timeout_ms: Optional[int] = Field(60000, description="等待队列超时时间，单位毫秒")
+    server_selection_timeout_ms: Optional[int] = Field(3000, description="服务器选择超时时间,单位毫秒")
+
+
+class MongodbManager:
+    @classmethod
+    def create(cls, config: MongodbConfig):
+        return cls(config=config)
+
+    def __init__(self, config: MongodbConfig):
+        """
+        初始化 MongoDB 客户端
+        """
+
+        self.host = config.host
+        self.port = config.port
+        self.database = config.database
+        self.username = config.username
+        self.password = config.password
+        self.ssl = config.ssl
+        self.max_pool_size = config.max_pool_size
+        self.min_pool_size = config.min_pool_size
+        self.wait_queue_timeout_ms = config.wait_queue_timeout_ms
+        self.server_selection_timeout_ms = config.server_selection_timeout_ms
+
+        if self.username and self.password:
+            uri = f'mongodb://{self.username}:{self.password}@{self.host}:{self.port}'
+        else:
+            uri = f'mongodb://{self.host}:{self.port}'
+
+        self.client = MongoClient(
+            uri,
+            maxPoolSize=self.max_pool_size,
+            minPoolSize=self.min_pool_size,
+            waitQueueTimeoutMS=self.wait_queue_timeout_ms,
+            serverSelectionTimeoutMS=self.server_selection_timeout_ms,
+            ssl=self.ssl,
+        )
+        self.db: Database = self.client[self.database]
+        self.logger = logging.getLogger('MongodbManager')
+
+    def get_collection(self, collection_name: str) -> Collection:
+        """
+        获取集合
+        :param collection_name: 集合名称
+        :return: 集合对象
+        """
+        return self.db[collection_name]
+
+    def create_collection(self, collection_name: str) -> Collection:
+        """
+        获取集合
+        :param collection_name: 集合名称
+        :return: 集合对象
+        """
+        collection_names = self.db.list_collection_names()
+        if collection_name not in collection_names:
+            return self.db.create_collection(name=collection_name)
+        else:
+            return self.get_collection(collection_name)
+
+    def insert_one(self, collection_name: str, document: Dict) -> Any:
+        """
+        插入单个文档
+        :param collection_name: 集合名称
+        :param document: 要插入的文档
+        :return: 插入结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.insert_one(document)
+
+    def insert_many(self, collection_name: str, documents: List[Dict]) -> Any:
+        """
+        插入多个文档
+        :param collection_name: 集合名称
+        :param documents: 要插入的文档列表
+        :return: 插入结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.insert_many(documents)
+
+    def find_one(self, collection_name: str, filter: Optional[Dict] = None, exlude: Optional[Dict] = None) -> Any:
+        """
+        查询单个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 查询结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.find_one(filter, exlude)
+
+    def find(self, collection_name: str, filter: Optional[Dict] = None, limit: int = 0, skip: int = 0, exlude: Optional[Dict] = None) -> List[Dict]:
+        """
+        查询多个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param limit: 查询结果数量限制
+        :param skip: 跳过的结果数量
+        :return: 查询结果列表
+        """
+        collection = self.get_collection(collection_name)
+        return list(collection.find(filter, exlude).limit(limit).skip(skip))
+
+    def update_one(self, collection_name: str, filter: Dict, update: Dict) -> Any:
+        """
+        更新单个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param update: 更新内容
+        :return: 更新结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.update_one(filter, update)
+
+    def update_many(self, collection_name: str, filter: Dict, update: Dict) -> Any:
+        """
+        更新多个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param update: 更新内容
+        :return: 更新结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.update_many(filter, update)
+
+    def delete_one(self, collection_name: str, filter: Dict) -> Any:
+        """
+        删除单个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 删除结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.delete_one(filter)
+
+    def delete_many(self, collection_name: str, filter: Dict) -> Any:
+        """
+        删除多个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 删除结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.delete_many(filter)
+
+    def count_documents(self, collection_name: str, filter: Optional[Dict] = None) -> int:
+        """
+        统计文档数量
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 文档数量
+        """
+        collection = self.get_collection(collection_name)
+        return collection.count_documents(filter)
+
+    def create_index(self, collection_name: str, keys: List[Tuple[str, int]]) -> Any:
+        """
+        创建索引
+        :param collection_name: 集合名称
+        :param keys: 索引键列表，例如 [("field1", 1), ("field2", -1)]
+        :return: 索引创建结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.create_index(keys)
+
+    def drop_collection(self, collection_name: str) -> None:
+        """
+        删除集合
+        :param collection_name: 集合名称
+        """
+        self.db.drop_collection(collection_name)
+
+    def close(self) -> None:
+        """
+        关闭 MongoDB 客户端连接
+        """
+        self.client.close()
+
+    def start_session(self):
+        """
+        开始一个新的会话
+        :return: 会话对象
+        """
+        return self.client.start_session()
+
+    def start_transaction(self, session):
+        """
+        开始一个新的事务
+        :param session: 会话对象
+        """
+        session.start_transaction()
+
+    def commit_transaction(self, session):
+        """
+        提交事务
+        :param session: 会话对象
+        """
+        session.commit_transaction()
+
+    def abort_transaction(self, session):
+        """
+        回滚事务
+        :param session: 会话对象
+        """
+        session.abort_transaction()
+
+    def end_session(self, session):
+        """
+        结束会话
+        :param session: 会话对象
+        """
+        session.end_session()
+
+    def bulk_write(self, collection_name: str, requests: List) -> Any:
+        """
+        批量写入操作
+        :param collection_name: 集合名称
+        :param requests: 批量写入请求列表
+        :return: 批量写入结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.bulk_write(requests)
+
+    def find_with_pagination(self, collection_name: str, filter: Optional[Dict] = None, page: int = 1, page_size: int = 10) -> List[Dict]:
+        """
+        分页查询
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param page: 当前页码
+        :param page_size: 每页大小
+        :return: 查询结果列表
+        """
+        collection = self.get_collection(collection_name)
+        skip = (page - 1) * page_size
+        return list(collection.find(filter).skip(skip).limit(page_size))
+
+    def _execute_with_retry(self, func, *args, **kwargs):
+        """
+        带重试机制的执行函数
+        :param func: 要执行的函数
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 函数执行结果
+        """
+        max_retries = 3
+        retries = 0
+        while retries < max_retries:
+            try:
+                return func(*args, **kwargs)
+            except AutoReconnect as e:
+                self.logger.warning(f"AutoReconnect occurred: {e}")
+                retries += 1
+        raise PyMongoError(f"Failed after {max_retries} retries")
+
+
+if __name__ == '__main__':
+    config = MongodbConfig(
+        host='45.120.102.142',
+        port=8883,
+    )
+    manager = MongodbManager.create(config)
+    print(manager)
+    col = manager.get_collection('default')
+    print(col)
+    res = manager.insert_one('default', {'content': 'test content'})
+    print(res)
+    doc = manager.find_one('default')
+    print(doc)

{agentic_kit_common-0.0.11 → agentic_kit_common-0.0.17}/agentic_kit_common/orm/execution.py

@@ -59,7 +59,7 @@ def is_readonly_expression(node: expressions.Expression, allowed_operations: Opt
     if allowed_operations:
         op_type = get_operation_type(node)
         # 检查操作类型
-        if op_type not in allowed_operations:
+        if op_type.lower() not in allowed_operations and op_type.upper() not in allowed_operations:
             return False, op_type
 
     if enable_wildcard_check and isinstance(node, expressions.Select) and node.find(expressions.Star):

{agentic_kit_common-0.0.11 → agentic_kit_common-0.0.17}/agentic_kit_common/orm/multi_session.py

@@ -64,9 +64,11 @@ class DatabaseEngineManager:
     def add_engine(self, engine_info: DatabaseEngineModel) -> bool:
         """添加数据库引擎"""
         with self._lock:
+            resource_uid =  engine_info.resource_uid
             engine_name = engine_info.engine_name
             database_uri = engine_info.database_uri
             database_name = engine_info.database_name
+            database_desc = engine_info.database_desc
             config = engine_info.config.model_dump().copy()
 
             if engine_name in self._engines:
@@ -91,8 +93,10 @@ class DatabaseEngineManager:
                 self._engines[engine_name] = engine
                 self._sessions[engine_name] = session_factory
                 self._engine_configs[engine_name] = {
+                    "resource_uid": resource_uid,
                     "database_uri": database_uri,
                     "database_name": database_name,
+                    "database_desc": database_desc,
                     "config": config or self._default_config.copy()
                 }
 

{agentic_kit_common-0.0.11 → agentic_kit_common-0.0.17}/agentic_kit_common/orm/schema.py

@@ -13,7 +13,9 @@ _DEFAULT_CONFIG = DatabaseEngineConfigModel()
 
 
 class DatabaseEngineModel(BaseModel):
+    resource_uid: str = Field("", description="数据库唯一ID")
     engine_name: str = Field(..., description="数据库引擎名字")
     database_uri: str = Field(..., description="数据库uir地址")
     database_name: str = Field(..., description="数据库名称")
+    database_desc: str = Field("", description="数据库描述信息")
     config: DatabaseEngineConfigModel = Field(_DEFAULT_CONFIG, description="配置信息")

agentic_kit_common-0.0.17/agentic_kit_common/sms/ali_sms_client.py

@@ -0,0 +1,54 @@
+from aliyunsdkcore.client import AcsClient
+from aliyunsdkcore.request import CommonRequest
+from dotenv import load_dotenv
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+load_dotenv()
+
+
+class SmsSettings(BaseSettings):
+    """统一放在 .env 中管理"""
+    ali_sms_access_key_id:     str = Field(..., env='ALI_SMS_ACCESS_KEY_ID')
+    ali_sms_access_key_secret: str = Field(..., env='ALI_SMS_ACCESS_KEY_SECRET')
+    ali_sms_sign_name:         str = Field('', env='ALI_SMS_SIGN_NAME')
+    ali_sms_template_code:     str = Field('', env='ALI_SMS_TEMPLATE_CODE')
+    ali_sms_region_id:     str = Field('cn-hangzhou', env='ALI_SMS_REGION_ID')
+
+
+class AliSmsClient:
+
+    _sms_settings = SmsSettings()
+
+    """线程安全：每个请求新建 AcsClient 即可"""
+    def __init__(self):
+        self.client = AcsClient(
+            self._sms_settings.ali_sms_access_key_id,
+            self._sms_settings.ali_sms_access_key_secret,
+            'cn-hangzhou'
+        )
+
+    def do_send_code(self, phone: str, code: str, ali_sms_sign_name: str = None, ali_sms_template_code: str = None) -> bool:
+        req = CommonRequest(domain='dysmsapi.aliyuncs.com',
+                            version='2017-05-25',
+                            action_name='SendSms')
+        req.set_method('POST')
+        req.set_protocol_type('https')
+        req.add_query_param('PhoneNumbers', phone)
+        req.add_query_param('SignName', self._sms_settings.ali_sms_sign_name if ali_sms_sign_name is None else ali_sms_sign_name)
+        req.add_query_param('TemplateCode', self._sms_settings.ali_sms_template_code if ali_sms_template_code is None else ali_sms_template_code)
+        req.add_query_param('TemplateParam', f'{{"code":"{code}"}}')
+
+        try:
+            self.client.do_action_with_exception(req)
+            return True
+        except Exception as e:
+            # 记录日志或告警
+            print('SMS send error:', e)
+            return False
+
+    @classmethod
+    def send_code(cls, phone: str, code: str, ali_sms_sign_name: str = None, ali_sms_template_code: str = None) -> bool:
+        client = AliSmsClient()
+        return client.do_send_code(phone=phone, code=code, ali_sms_sign_name=ali_sms_sign_name, ali_sms_template_code=ali_sms_template_code)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-kit-common
-Version: 0.0.11
+Version: 0.0.17
 Summary: Common utilities and tools for agentic kit ecosystem
 Home-page: 
 Author: manson
@@ -24,11 +24,15 @@ Requires-Dist: langchain_core
 Requires-Dist: langgraph
 Requires-Dist: langchain_community
 Requires-Dist: langchain_experimental
+Requires-Dist: langchain-openai
 Requires-Dist: mysql-connector-python
 Requires-Dist: sqlalchemy
 Requires-Dist: sqlglot
 Requires-Dist: pymilvus
 Requires-Dist: xinference_client
+Requires-Dist: pymongo
+Requires-Dist: aliyun-python-sdk-core
+Requires-Dist: aliyun-python-sdk-dysmsapi
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

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

@@ -6,10 +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/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/minio/__init__.py
 agentic_kit_common/minio/minio_manager.py
+agentic_kit_common/mongodb/__init__.py
+agentic_kit_common/mongodb/mongodb_manager.py
 agentic_kit_common/orm/__init__.py
 agentic_kit_common/orm/base.py
 agentic_kit_common/orm/execution.py
@@ -17,6 +22,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/sms/__init__.py
+agentic_kit_common/sms/ali_sms_client.py
 agentic_kit_common/vector/__init__.py
 agentic_kit_common/vector/embedding/__init__.py
 agentic_kit_common/vector/embedding/embedding.py

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

@@ -6,8 +6,12 @@ langchain_core
 langgraph
 langchain_community
 langchain_experimental
+langchain-openai
 mysql-connector-python
 sqlalchemy
 sqlglot
 pymilvus
 xinference_client
+pymongo
+aliyun-python-sdk-core
+aliyun-python-sdk-dysmsapi

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

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='agentic-kit-common',
-    version="0.0.11",
+    version="0.0.17",
     author="manson",
     author_email="manson.li3307@gmail.com",
     description='Common utilities and tools for agentic kit ecosystem',
@@ -37,6 +37,7 @@ setup(
         "langgraph",
         "langchain_community",
         "langchain_experimental",
+        "langchain-openai",
 
         # sqlalchemy
         "mysql-connector-python",
@@ -50,6 +51,13 @@ setup(
 
         # xinference
         "xinference_client",
+
+        # mongodb
+        "pymongo",
+
+        # aliyun sms
+        "aliyun-python-sdk-core",
+        "aliyun-python-sdk-dysmsapi",
     ],
     keywords=['AI', 'LLM', 'Agent', 'MinIO', 'Storage', 'Common', 'Utilities'],
     include_package_data=True,

agentic_kit_common-0.0.11/agentic_kit_common/log/logger.py

@@ -1,16 +0,0 @@
-import logging
-
-
-def setup_logger(tag, level):
-    logger = logging.getLogger(tag)
-    logger.setLevel(level)
-
-    if not logger.handlers:
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-    return logger