mm-qa-mcp 1.0.0__tar.gz → 2.0.0__tar.gz

{mm_qa_mcp-1.0.0/mm_qa_mcp.egg-info → mm_qa_mcp-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mm_qa_mcp
-Version: 1.0.0
+Version: 2.0.0
 Summary: QA agent service 集合
 Author-email: xingyun <xingyun@minimaxi.com>
 License: MIT

{mm_qa_mcp-1.0.0 → mm_qa_mcp-2.0.0}/minimax_qa_mcp/server.py

@@ -19,7 +19,7 @@ from minimax_qa_mcp.src.get_weaviate_info.get_weaviate_info import GetWeaviateIn
 from minimax_qa_mcp.src.grafana.service import GetFromGrafana, GetApiFromGrafana
 from minimax_qa_mcp.src.gateway_case.get_case import CaseGrafanaService
 from minimax_qa_mcp.src.query_segments.query_segments import query_main, TYPE_API, TYPE_FUNC, TYPE_CODE, TYPE_ANY, TYPE_FUNC_DETAIL
-
+from minimax_qa_mcp.src.get_full_api_call_chain.get_full_api_call_chain import GetFullApiCallChain
 
 # Initialize FastMCP server
 mcp = FastMCP("mcp")
@@ -162,6 +162,23 @@ async def get_weaviate_info(input_data: str) -> dict:
     return result
 
 
+@mcp.tool()
+async def get_full_api_call_chain(api_path: str) -> dict:
+    """
+    获取API调用链
+    Args:
+        api_path: str，API路径(demo:/weaver/api/v1/ugc/get_npc_list_by_user_id)
+    Return:
+        API调用链信息
+    """
+    logger.info(f"===== The input params is :{api_path}")
+
+    api_call_chain = GetFullApiCallChain(api_path)
+    result = api_call_chain.get_full_call_chain()
+    logger.info(f"===== The result of get_full_api_call_chain is :{result}")
+    return result
+
+
 def main():
     print("Starting Minimax QA MCP server")
     """Run the Minimax QA MCP server"""

{mm_qa_mcp-1.0.0/minimax_qa_mcp/src/demo_langchain → mm_qa_mcp-2.0.0/minimax_qa_mcp/src/get_full_api_call_chain}/__init__.py

@@ -1,6 +1,6 @@
 """
 coding:utf-8
 @Software: PyCharm
-@Time: 2025/4/10 15:12
+@Time: 2025/6/8 14:37
 @Author: xingyun
 """

mm_qa_mcp-2.0.0/minimax_qa_mcp/src/get_full_api_call_chain/get_full_api_call_chain.py

@@ -0,0 +1,291 @@
+"""
+coding:utf-8
+@Software: PyCharm
+@Time: 2025/6/8 14:37
+@Author: xingyun
+@description:
+ 根据api_path 获取完整的API调用链
+ 输入：api_path
+ 输出：完整的API调用链（包括所有下游调用）
+"""
+
+
+from minimax_qa_mcp.utils.mysql_op import MysqlOp
+from minimax_qa_mcp.utils.logger import logger
+
+default_service = "weaver.gateway.weaver"
+
+
+class GetFullApiCallChain:
+    def __init__(self, api_path):
+        """
+        初始化调用链获取类
+        :param api_path:  /path/to/endpoint (HTTP路径格式)
+        """
+        self.api_path = api_path
+        self.mysql_op = MysqlOp()
+        # API路径，获取服务名和方法名
+        self.caller_service = default_service
+        self.caller_method = api_path
+        # 存储已访问的调用路径，避免循环调用
+        self.visited_paths = set()
+        # 存储最终的调用链结果
+        self.call_chain_results = []
+
+    def get_downstream_calls(self, service, method):
+        """
+        获取指定服务和方法的所有下游调用
+        :param service: 服务名称
+        :param method: 方法名称
+        :return: 下游调用列表
+        """
+        sql = """
+        SELECT caller_service, caller_method, callee_service, callee_method, call_type, code_chain 
+        FROM qa_tools.code_call_chain 
+        WHERE caller_service = %s AND caller_method = %s
+        """
+
+        result = self.mysql_op.connect(sql_=sql, data=(service, method), op='select')
+        return result if result else []
+
+    def _build_call_path(self, call_record, level=0, path=None):
+        """
+        递归构建调用路径
+        :param call_record: 当前调用记录
+        :param level: 当前调用层级
+        :param path: 当前已构建的路径
+        :return: 构建完成的调用路径
+        """
+        caller_service = call_record[0]
+        caller_method = call_record[1]
+        callee_service = call_record[2]
+        callee_method = call_record[3]
+        call_type = call_record[4]
+
+        # 构建调用路径标识
+        call_id = f"{caller_service}.{caller_method} -> {callee_service}.{callee_method}"
+
+        # 检查是否已经访问过该路径，避免循环调用
+        if call_id in self.visited_paths:
+            return
+
+        self.visited_paths.add(call_id)
+
+        # 初始化路径
+        if path is None:
+            path = []
+
+        # 添加当前调用到路径
+        current_call = {
+            "level": level,
+            "caller_service": caller_service,
+            "caller_method": caller_method,
+            "callee_service": callee_service,
+            "callee_method": callee_method,
+            "call_type": call_type
+        }
+
+        path.append(current_call)
+
+        # 复制当前路径，添加到结果中
+        self.call_chain_results.append(path.copy())
+
+        # 递归获取下游调用
+        downstream_calls = self.get_downstream_calls(callee_service, callee_method)
+        for downstream_call in downstream_calls:
+            self._build_call_path(downstream_call, level + 1, path.copy())
+
+    def get_full_call_chain(self):
+        """
+        获取完整的API调用链
+        :return: 字典，包含原始API信息和完整调用链
+        """
+        # 先清空之前的结果
+        self.visited_paths = set()
+        self.call_chain_results = []
+
+        # 获取起始API的下游调用
+        downstream_calls = self.get_downstream_calls(self.caller_service, self.caller_method)
+
+        if not downstream_calls:
+            logger.info(f"未找到API {self.caller_service}.{self.caller_method} 的下游调用")
+            return {
+                "api_path": self.api_path,
+                "service": self.caller_service,
+                "method": self.caller_method,
+                "downstream_calls_count": 0,
+                "downstream_calls": [],
+                "call_tree": {},
+                "statistics": {
+                    "total_calls": 0,
+                    "max_depth": 0,
+                    "service_count": 0,
+                    "call_type_distribution": {}
+                }
+            }
+
+        # 构建每个下游调用的完整路径
+        for call in downstream_calls:
+            self._build_call_path(call)
+
+        # 构建树形结构
+        call_tree = self._build_call_tree()
+
+        # 计算统计信息
+        statistics = self._calculate_statistics()
+
+        # 格式化结果
+        formatted_results = []
+        for path in self.call_chain_results:
+            formatted_path = {
+                "path_length": len(path),
+                "calls": []
+            }
+            for call in path:
+                formatted_path["calls"].append({
+                    "level": call["level"],
+                    "caller": f"{call['caller_service']}.{call['caller_method']}",
+                    "callee": f"{call['callee_service']}.{call['callee_method']}",
+                    "call_type": call["call_type"],
+                    "detail": f"{call['caller_service']}.{call['caller_method']} -> {call['callee_service']}.{call['callee_method']} ({call['call_type']})"
+                })
+            formatted_results.append(formatted_path)
+
+        return {
+            "api_path": self.api_path,
+            "service": self.caller_service,
+            "method": self.caller_method,
+            "downstream_calls_count": len(self.call_chain_results),
+            "downstream_calls": formatted_results,
+            "call_tree": call_tree,
+            "statistics": statistics
+        }
+
+    def _build_call_tree(self):
+        """
+        构建调用树形结构
+        """
+        tree = {}
+
+        for path in self.call_chain_results:
+            current_node = tree
+            for call in path:
+                key = f"{call['callee_service']}.{call['callee_method']}"
+                if key not in current_node:
+                    current_node[key] = {
+                        "service": call['callee_service'],
+                        "method": call['callee_method'],
+                        "call_type": call['call_type'],
+                        "caller": f"{call['caller_service']}.{call['caller_method']}",
+                        "children": {}
+                    }
+                current_node = current_node[key]["children"]
+
+        return tree
+
+    def _calculate_statistics(self):
+        """
+        计算调用链的统计信息
+        """
+        # 统计各种信息
+        service_set = set()
+        call_type_count = {}
+        max_depth = 0
+
+        for path in self.call_chain_results:
+            # 更新最大深度
+            if len(path) > max_depth:
+                max_depth = len(path)
+
+            # 收集服务和调用类型
+            for call in path:
+                service_set.add(call['callee_service'])
+                call_type = call['call_type']
+                call_type_count[call_type] = call_type_count.get(call_type, 0) + 1
+
+        # 统计每个服务被调用的次数
+        service_call_count = {}
+        for path in self.call_chain_results:
+            for call in path:
+                service_key = f"{call['callee_service']}.{call['callee_method']}"
+                service_call_count[service_key] = service_call_count.get(service_key, 0) + 1
+
+        # 找出被调用最多的服务
+        top_called_services = sorted(service_call_count.items(), key=lambda x: x[1], reverse=True)[:5]
+
+        return {
+            "total_calls": len(self.call_chain_results),
+            "max_depth": max_depth,
+            "service_count": len(service_set),
+            "call_type_distribution": call_type_count,
+            "top_called_services": top_called_services
+        }
+
+    def print_call_chain(self):
+        """
+        以可读性强的格式打印完整的调用链
+        """
+        result = self.get_full_call_chain()
+
+        # 打印基本信息
+        print(f"\n{'=' * 100}")
+        print(f"📍 API调用链分析报告")
+        print(f"{'=' * 100}")
+        print(f"🔗 API路径: {result['api_path']}")
+        print(f"🏢 服务名: {result['service']}")
+        print(f"📋 方法名: {result['method']}")
+        print(f"\n{'=' * 100}")
+
+        # 打印统计信息
+        stats = result['statistics']
+        print(f"📊 统计信息:")
+        print(f"  • 总调用链数: {stats['total_calls']}")
+        print(f"  • 最大调用深度: {stats['max_depth']}")
+        print(f"  • 涉及服务数量: {stats['service_count']}")
+        print(f"  • 调用类型分布: {stats['call_type_distribution']}")
+
+        if stats.get('top_called_services'):
+            print(f"\n  • 🔥 高频调用服务 TOP5:")
+            for service, count in stats['top_called_services']:
+                print(f"    - {service} (被调用 {count} 次)")
+
+        print(f"\n{'=' * 100}")
+
+        if result.get('downstream_calls_count', 0) == 0:
+            print("❌ 没有找到下游调用")
+            print(f"{'=' * 100}\n")
+            return result
+
+        # 打印树形结构
+        print("🌳 调用树形结构:")
+        print(f"{'-' * 100}")
+        self._print_tree(result['call_tree'], indent=0)
+
+        return result
+
+    def _print_tree(self, tree, indent=0, prefix=""):
+        """
+        递归打印树形结构
+        """
+        items = list(tree.items())
+        for i, (key, node) in enumerate(items):
+            is_last = i == len(items) - 1
+
+            # 打印当前节点
+            connector = "└── " if is_last else "├── "
+            type_symbol = {"HTTP": "🌐", "RPC": "⚡", "LOCAL": "🏠"}.get(node['call_type'], "📡")
+            print(f"{prefix}{connector}{type_symbol} {key}")
+
+            # 打印子节点
+            if node['children']:
+                extension = "    " if is_last else "│   "
+                self._print_tree(node['children'], indent + 1, prefix + extension)
+
+
+if __name__ == '__main__':
+    # 使用示例 - HTTP路径格式
+    api_path_ = "/weaver/api/v1/ugc/get_npc_list_by_user_id"
+    call_chain = GetFullApiCallChain(api_path_)
+    result = call_chain.print_call_chain()
+    print("结果:")
+    print(result)

mm_qa_mcp-2.0.0/minimax_qa_mcp/utils/mysql_op.py

@@ -0,0 +1,175 @@
+"""
+coding:utf-8
+@Software: PyCharm
+@Time: 2024/6/4 下午5:48
+@Author: xingyun
+"""
+
+import pymysql
+
+from minimax_qa_mcp.utils.logger import logger
+
+
+class MysqlOp(object):
+    def __init__(self):
+        self.password = "ngo0nZYnPvpoke7P"
+        self.host = "10.11.24.40"
+        self.database = "qa_tools"
+        self.user = "qa_test"
+        self.port = 3306
+
+    def connect(self, sql_, data=None, op=None):
+        # 连接到MySQL数据库
+        conn = pymysql.connect(host=self.host,
+                               user=self.user,
+                               password=self.password,
+                               db=self.database,
+                               port=self.port)
+
+        # 创建Cursor对象
+        try:
+            with conn.cursor() as cursor:
+                if op == 'insert':
+                    cursor.execute(sql_, data)
+                    conn.commit()
+                    # 插入成功后，可以获取插入数据的ID（如果表有自增主键）
+                    last_id = cursor.lastrowid
+                    logger.info(f"Last inserted record ID is {last_id}")
+                    return last_id
+                elif op == 'select':
+                    cursor.execute(sql_, data)
+                    # 获取查询结果
+                    results = cursor.fetchall()
+                    # 打印结果
+                    for row in results:
+                        logger.info(row)
+                    return results
+                elif op == 'delete':
+                    cursor.execute(sql_, data)
+                    # 提交到数据库执行
+                    conn.commit()
+                    logger.info("记录已成功删除。")
+                elif op == 'update':
+                    cursor.execute(sql_, data)
+                    # 提交到数据库执行
+                    conn.commit()
+                    logger.info("数据更新成功！")
+                    # 获取更新的行数
+                    affected_rows = cursor.rowcount
+                    logger.info(f"Number of rows affected: {affected_rows}")
+                    return affected_rows
+
+        except pymysql.MySQLError as e:
+            # 如果发生错误，打印错误信息
+            logger.info(f"Error: {e}")
+        finally:
+            # 关闭Cursor和Connection
+            conn.close()
+
+    def batch_insert(self, sql_, batch_data):
+        """
+        批量插入数据到MySQL数据库
+        :param sql_: 带有占位符的SQL插入语句
+        :param batch_data: 包含多组参数的列表，每组参数对应一条记录
+        :return: 成功插入的记录数
+        """
+        if not batch_data:
+            logger.info("批量插入数据为空，跳过")
+            return 0
+            
+        # 连接到MySQL数据库
+        conn = pymysql.connect(host=self.host,
+                              user=self.user,
+                              password=self.password,
+                              db=self.database,
+                              port=self.port)
+                              
+        success_count = 0
+        try:
+            with conn.cursor() as cursor:
+                # 执行批量插入
+                success_count = cursor.executemany(sql_, batch_data)
+                conn.commit()
+                logger.info(f"成功批量插入 {success_count} 条记录")
+                return success_count
+        except pymysql.MySQLError as e:
+            # 如果发生错误，回滚事务并打印错误信息
+            conn.rollback()
+            logger.info(f"批量插入错误: {e}")
+            return 0
+        finally:
+            # 关闭连接
+            conn.close()
+            
+    def batch_update(self, sql_, batch_data):
+        """
+        批量更新MySQL数据库中的记录
+        :param sql_: 带有占位符的SQL更新语句
+        :param batch_data: 包含多组参数的列表，每组参数对应一条记录
+        :return: 成功更新的记录数
+        """
+        if not batch_data:
+            logger.info("批量更新数据为空，跳过")
+            return 0
+            
+        # 连接到MySQL数据库
+        conn = pymysql.connect(host=self.host,
+                              user=self.user,
+                              password=self.password,
+                              db=self.database,
+                              port=self.port)
+                              
+        success_count = 0
+        try:
+            with conn.cursor() as cursor:
+                # 执行批量更新
+                success_count = cursor.executemany(sql_, batch_data)
+                conn.commit()
+                logger.info(f"成功批量更新 {success_count} 条记录")
+                return success_count
+        except pymysql.MySQLError as e:
+            # 如果发生错误，回滚事务并打印错误信息
+            conn.rollback()
+            logger.info(f"批量更新错误: {e}")
+            return 0
+        finally:
+            # 关闭连接
+            conn.close()
+
+
+if __name__ == '__main__':
+    # group_id = '112233445566'
+    # bank_account_no = 'test_1234'
+    # card_num = 'test_card_num'
+    # redis_key = 'cred_group_id_data'
+    # ping_an_resp = 'xxx'
+    # time_stamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    # mysql_op = MysqlOp('qa_db')
+    # # sql_ = 'insert into pingan_un_bank_info (group_id, bank_account_no, card_num, redis_key, pingan_url_resp, creat_time, delete_time) values (%s, %s, %s, %s, %s, %s, %s)'
+    # # mysql_op.connect(sql_=sql_, data=(group_id, bank_account_no, card_num, redis_key, ping_an_resp, time_stamp, time_stamp), op='insert')
+    # update_sql = 'update pingan_un_bank_info set pingan_url_resp = %s where group_id = %s'
+    # mysql_op.connect(sql_=update_sql, data=('test_resp sxxxxxxxxxxxxxx', '112233445566'), op='update')
+
+    # operator_ = 'xingyun1'
+    # psm_ = 'open_platform'
+    # task_name_ = '开放平台线上环境巡检'
+    # job_id = '20240612124204'
+    # report_url_ = ''
+    # report_tos_key_ = 'qa-tool-1315599187/swingReport/20240604/swing_report_20240604_123456.zip'
+    # status_ = True
+    # create_time_ = str(datetime.now())
+    # env_ = 'prod'
+    # sql = 'insert into swing_report (operator, psm, task_name, task_id, report_tos_key, status, create_time, env, job_id) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)'
+    # MysqlOp().connect(sql, data=(operator_, psm_, task_name_, task_id_, report_tos_key_, status_, create_time_, env_, job_id), op='insert')
+    # sql = 'select * from swing_report limit 10'
+    # sql = 'select * from user_group limit 10'
+    # # # sql = 'delete from swing_report where operator = %s'
+    # # mys = MysqlOp('kaiping_usercore_online_db')
+    # mys.connect(sql_=sql, data=None, op='select')
+    # sql = 'update swing_report set status = %s where id = %s'
+    # mys.connect(sql_=sql, data=('2', 1), op='update')
+    sql = "select * from qa_tools.api_meta where psm_name = %s"
+    mysql_op = MysqlOp()
+    result = mysql_op.connect(sql, data=('weaver.conversation.biz',), op='select')
+    print(result)
+

{mm_qa_mcp-1.0.0 → mm_qa_mcp-2.0.0/mm_qa_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mm_qa_mcp
-Version: 1.0.0
+Version: 2.0.0
 Summary: QA agent service 集合
 Author-email: xingyun <xingyun@minimaxi.com>
 License: MIT

{mm_qa_mcp-1.0.0 → mm_qa_mcp-2.0.0}/mm_qa_mcp.egg-info/SOURCES.txt

@@ -7,13 +7,13 @@ minimax_qa_mcp/server.py
 minimax_qa_mcp/conf/__init__.py
 minimax_qa_mcp/conf/conf.ini
 minimax_qa_mcp/src/__init__.py
-minimax_qa_mcp/src/demo_langchain/__init__.py
-minimax_qa_mcp/src/demo_langchain/langchain_demo.py
 minimax_qa_mcp/src/gateway_case/__init__.py
 minimax_qa_mcp/src/gateway_case/get_case.py
 minimax_qa_mcp/src/generator_case/__init__.py
 minimax_qa_mcp/src/generator_case/generator_case.py
 minimax_qa_mcp/src/generator_case/generator_case_langchain.py
+minimax_qa_mcp/src/get_full_api_call_chain/__init__.py
+minimax_qa_mcp/src/get_full_api_call_chain/get_full_api_call_chain.py
 minimax_qa_mcp/src/get_weaviate_info/__init__.py
 minimax_qa_mcp/src/get_weaviate_info/get_weaviate_info.py
 minimax_qa_mcp/src/grafana/__init__.py
@@ -24,6 +24,7 @@ minimax_qa_mcp/src/xmind2markdown/__init__.py
 minimax_qa_mcp/src/xmind2markdown/xmind_to_markdown.py
 minimax_qa_mcp/utils/__init__.py
 minimax_qa_mcp/utils/logger.py
+minimax_qa_mcp/utils/mysql_op.py
 minimax_qa_mcp/utils/utils.py
 mm_qa_mcp.egg-info/PKG-INFO
 mm_qa_mcp.egg-info/SOURCES.txt

{mm_qa_mcp-1.0.0 → mm_qa_mcp-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mm_qa_mcp"
-version = "1.0.0"
+version = "2.0.0"
 description = "QA agent service 集合"
 readme = "README.md"
 requires-python = ">=3.10"

mm_qa_mcp-1.0.0/minimax_qa_mcp/src/demo_langchain/langchain_demo.py

@@ -1 +0,0 @@
-