LightAgent 0.2.85__tar.gz → 0.2.95__tar.gz

{lightagent-0.2.85 → lightagent-0.2.95}/LightAgent/la_core.py

@@ -1,6 +1,5 @@
 import re
-import traceback
-from typing import List, Dict, Any, Callable, Union, Iterable, Optional, Generator
+from typing import List, Dict, Any, Callable, Union, Iterable, Optional, Generator, AsyncGenerator
 from copy import deepcopy
 import importlib.util
 import random
@@ -12,14 +11,24 @@ import os
 import httpx
 import importlib
 from openai.types.chat import ChatCompletionChunk
+import inspect
+import traceback
+from mcp import ClientSession, StdioServerParameters, types
+from contextlib import AsyncExitStack
+
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
+import asyncio
+from functools import partial
+
 
 # 全局工具注册表
 _FUNCTION_MAPPINGS = {}  # 工具名称 -> 工具函数
-_FUNCTION_INFO = {}   # 工具名称 -> 工具info信息
+_FUNCTION_INFO = {}  # 工具名称 -> 工具info信息
 _OPENAI_FUNCTION_SCHEMAS = []  # OpenAI 格式的工具描述
 _PROMPT_FUNCTION_SCHEMAS = []  # prompt 格式的工具描述
 
-__version__ = "0.2.85"  # 你可以根据需要设置版本号
+__version__ = "0.3.0"  # 你可以根据需要设置版本号
 
 
 def register_tool_manually(tools: List[Union[str, Callable]]) -> bool:
@@ -88,35 +97,44 @@ def load_tool(tool_name: str, tools_directory: str = "tools"):
     raise AttributeError(f"Tool '{tool_name}' is not properly defined in {tool_path}")
 
 
-def dispatch_tool(tool_name: str, tool_params: Dict[str, Any]) -> Union[str, Generator[str, None, None]]:
+async def dispatch_tool(tool_name: str, tool_params: Dict[str, Any]) -> Union[
+    str, Generator[str, None, None], AsyncGenerator[str, None]]:
     """
-    调用工具执行，支持流式输出。
-
-    :param tool_name: 工具名称
-    :param tool_params: 工具参数
-    :return: 如果工具是流式输出，返回生成器；否则返回字符串结果。
+    调用工具执行，支持同步/异步工具及流式输出。
     """
     if tool_name not in _FUNCTION_MAPPINGS:
         return f"Tool `{tool_name}` not found."
 
     tool_call = _FUNCTION_MAPPINGS[tool_name]
     try:
-        # print(f"Calling tool: {tool_name} with params: {tool_params}")  # 调试信息
-        result = tool_call(**tool_params)
+        # 处理不同类型的流式输出
+        # 区分同步/异步工具
+        if inspect.iscoroutinefunction(tool_call):
+            # result = await tool_call(**tool_params)
+            # 将参数以字典形式传递给包装器
+            result = await tool_call(**tool_params) if inspect.iscoroutinefunction(tool_call) else tool_call(
+                **tool_params)
+        else:
+            result = tool_call(**tool_params)
 
-        # 如果工具返回的是可迭代对象（如生成器），则逐块处理并返回生成器
-        if isinstance(result, Iterable) and not isinstance(result, (str, bytes)):
+        # 处理不同类型的流式输出
+        if inspect.isasyncgen(result):
+            return async_stream_generator(result)
+        elif inspect.isgenerator(result):
             return stream_generator(result)
-        # 否则，返回字符串结果
         else:
             return str(result)
     except Exception as e:
-        # print(f"Tool call failed: {e}")  # 调试信息
         return traceback.format_exc()
 
 
-def stream_generator(result):
-    for chunk in result:
+async def async_stream_generator(async_gen: AsyncGenerator) -> AsyncGenerator[str, None]:
+    async for chunk in async_gen:
+        yield chunk
+
+
+def stream_generator(sync_gen: Generator) -> Generator[str, None, None]:
+    for chunk in sync_gen:
         yield chunk
 
 
@@ -154,26 +172,223 @@ def get_tools_str() -> str:
     return tools_str
 
 
+class MCPClientManager:
+    """增强版MCP客户端管理器"""
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = AsyncExitStack()
+        self._streams_context = None
+        self._session_context = None
+        self.server_sessions = {}  # 存储不同服务器的会话
+
+    async def _call_tool_wrapper(self, tool_name: str, target_server: str, **kwargs):
+        """参数转换适配器"""
+        return await self.call_tool(
+            tool_name=tool_name,
+            arguments=kwargs,
+            target_server=target_server
+        )
+
+    async def _create_session(self, server_name: str, config: dict):
+        """创建并管理会话上下文"""
+        if 'url' in config:
+            # SSE 服务器连接
+            self._streams_context = sse_client(
+                url=config['url'],
+                headers=config.get('headers', {})
+            )
+            streams = await self.exit_stack.enter_async_context(self._streams_context)
+            self._session_context = ClientSession(*streams)
+            self.session = await self.exit_stack.enter_async_context(self._session_context)
+        else:
+            # 标准输入输出服务器连接
+            server_params = StdioServerParameters(
+                command=config["command"],
+                args=config["args"],
+                env=config.get("env")
+            )
+            transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+            stdio, write = transport
+            self._session_context = ClientSession(stdio, write)
+            self.session = await self.exit_stack.enter_async_context(self._session_context)
+
+        await self.session.initialize()
+        self.server_sessions[server_name] = self.session
+
+    async def cleanup(self):
+        """清理所有会话资源"""
+        await self.exit_stack.__aexit__(None, None, None)
+        self.server_sessions.clear()
+
+    async def register_mcp_tool(self) -> bool:
+        """
+        自动注册所有MCP服务的工具到全局字典
+        :param config: MCP服务配置（与call_tool使用的相同配置）
+        :return: 是否至少成功注册一个工具
+        """
+        registered_count = 0
+        enabled_servers = [
+            (name, config)
+            for name, config in self.config["mcpServers"].items()
+            if not config["disabled"]
+        ]
+
+        for server_name, config in enabled_servers:
+            try:
+                # 创建会话连接
+                # print(server_name,config)
+                await self._create_session(server_name, config)
+
+                # 获取工具列表
+                tools_response = await self.session.list_tools()
+                print(f"🔍 Registering tools for server : {server_name} ...")
+
+                # 注册工具处理逻辑
+                for tool in tools_response.tools:
+                    try:
+                        # 构建工具元数据
+                        tool_info = {
+                            "tool_name": tool.name,
+                            "tool_description": tool.description,
+                            "tool_params": []
+                        }
+
+                        # 解析参数模式
+                        properties = tool.inputSchema.get("properties", {})
+                        required_fields = tool.inputSchema.get("required", [])
+
+                        for param_name, param_schema in properties.items():
+                            tool_info["tool_params"].append({
+                                "name": param_name,
+                                "type": param_schema.get("type", "string"),
+                                "description": param_schema.get("title", ""),
+                                "required": param_name in required_fields
+                            })
+
+                        # 注册到全局字典
+                        _FUNCTION_INFO[tool.name] = tool_info
+                        _FUNCTION_MAPPINGS[tool.name] = partial(
+                            self._call_tool_wrapper,
+                            tool_name=tool.name,
+                            target_server=server_name
+                        )
+
+                        # 构建OpenAI格式
+                        openai_schema = {
+                            "type": "function",
+                            "function": {
+                                "name": tool.name,
+                                "description": tool.description,
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {
+                                        k: {"type": v["type"], "description": v.get("title", "")}
+                                        for k, v in properties.items()
+                                    },
+                                    "required": required_fields
+                                }
+                            }
+                        }
+                        _OPENAI_FUNCTION_SCHEMAS.append(openai_schema)
+
+                        registered_count += 1
+                        print(f"✅ The registered tool : {tool.name}")
+
+                    except Exception as e:
+                        print(f"⚠️ 工具 {tool.name} 注册失败: {str(e)}")
+                        continue
+                print(f"🟢 {registered_count} tools have been registered")
+
+            except Exception as e:
+                print(f"🔴 服务器 {server_name} 连接失败: {str(e)}")
+                continue
+        # 清理
+        await self.cleanup()
+        return registered_count > 0
+
+    async def call_tool(self, tool_name: str, arguments: dict, target_server: str = None):
+        """
+        通用工具调用方法
+        :param tool_name: 要调用的工具名称
+        :param arguments: 工具参数字典
+        :param target_server: 指定服务器名称（可选）
+        :return: 工具调用结果
+        """
+        enabled_servers = [
+            (name, config)
+            for name, config in self.config["mcpServers"].items()
+            if not config["disabled"]
+        ]
+
+        if target_server:
+            enabled_servers = [s for s in enabled_servers if s[0] == target_server]
+
+        for server_name, config in enabled_servers:
+            try:
+                # 复用已建立的会话
+                session = self.server_sessions.get(server_name)
+                # print(111,server_name,session)
+                # print(222,server_name,config)
+                if not session:
+                    await self._create_session(server_name, config)
+                    session = self.session
+
+                # 获取工具列表
+                tools = await session.list_tools()
+                available_tools = {t.name: t for t in tools.tools}
+
+                if tool_name in available_tools:
+                    # 验证参数类型
+                    schema = available_tools[tool_name].inputSchema
+                    self._validate_arguments(arguments, schema)
+
+                    # 执行调用
+                    result = await session.call_tool(tool_name, arguments)
+                    # print(f"mcp工具运行结果: {result.content[0].text}")
+                    # 调用完成清理session
+                    await self.cleanup()
+                    return {
+                        "server": server_name,
+                        "tool": tool_name,
+                        "result": result.content[0].text
+                    }
+
+            except Exception as e:
+                print(f"调用服务器 {server_name} 失败: {str(e)}")
+                continue
+
+        raise ValueError(f"工具 {tool_name} 在可用服务器中未找到")
+
+    def _validate_arguments(self, arguments: dict, schema: dict):
+        """简单参数校验（可选）"""
+        required_fields = schema.get("required", [])
+        for field in required_fields:
+            if field not in arguments:
+                raise ValueError(f"缺少必要参数: {field}")
+
+
 class LightAgent:
-    __version__ = "0.2.85"  # 将版本号放在类中
+    __version__ = "0.3.0"  # 将版本号放在类中
 
     def __init__(
             self,
             *,
             name: Optional[str] = None,  # 代理名称
             instructions: Optional[str] = None,  # 代理指令
-            role: Optional[str] = None,
-            model: str,
-            api_key: str | None = None,
-            base_url: str | httpx.URL | None = None,
-            websocket_base_url: str | httpx.URL | None = None,
+            role: Optional[str] = None,  # 代理角色
+            model: str,  # agent模型名称
+            api_key: str | None = None,  # 模型 api key
+            base_url: str | httpx.URL | None = None,  # 模型 base url
+            websocket_base_url: str | httpx.URL | None = None,  # 模型 websocket base url
             memory=None,  # 支持外部传入记忆模块
             tree_of_thought: bool = False,  # 是否启用链式思考
-            tot_model: str | None = None,
-            tot_api_key: str | None = None,
-            tot_base_url: str | httpx.URL | None = None,
+            tot_model: str | None = None,  # 链式思考模型
+            tot_api_key: str | None = None,  # 链式思考模型API密钥
+            tot_base_url: str | httpx.URL | None = None,  # 链式思考模型base_url
             self_learning: bool = False,  # 是否启用agent自我学习
-            tools: List[Union[str, Callable]] = None,  # 支持混合输入
+            tools: List[Union[str, Callable]] = None,  # 支持工具混合输入
             debug: bool = False,  # 是否启用调试模式
             log_level: str = "INFO",  # 日志级别（INFO, DEBUG, ERROR）
             log_file: Optional[str] = None  # 日志文件路径
@@ -198,6 +413,8 @@ class LightAgent:
         :param log_level: 日志级别（INFO, DEBUG, ERROR）。
         :param log_file: 日志文件路径。
         """
+        self.mcp_setting = None
+        self.mcp_client = None
         if not model:
             model = "gpt-4o-mini"  # 默认模型
         if not api_key:
@@ -206,7 +423,7 @@ class LightAgent:
             base_url = os.environ.get("OPENAI_BASE_URL")
         self.loaded_tools = {}  # 用于存储已加载的工具函数
         if not name:
-            random_suffix = random.randint(10000000, 99999999)  # 生成一个8位随机数
+            random_suffix = random.randint(10000000, 99999999)  # 生成一个8位随机数作为agent编号
             name = f"LightAgent{random_suffix}"
         self.name = name
         if not instructions:
@@ -236,6 +453,8 @@ class LightAgent:
             # 初始化工具列表
             self.load_tools(tools)
             # register_tool_manually(tools)
+
+
         if api_key is None:
             raise ValueError(
                 "The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable"
@@ -247,8 +466,8 @@ class LightAgent:
             base_url = f"https://api.openai.com/v1"
 
         self.client = OpenAI(
-            base_url = base_url,
-            api_key = self.api_key
+            base_url=base_url,
+            api_key=self.api_key
         )
         if self.tree_of_thought:
             if tot_api_key is None:
@@ -259,8 +478,8 @@ class LightAgent:
                 tot_model = "deepseek-r1"  # 默认思维推理模型为deepseek-r1
             self.tot_model = tot_model
             self.tot_client = OpenAI(
-                base_url = tot_base_url,
-                api_key = tot_api_key
+                base_url=tot_base_url,
+                api_key=tot_api_key
             )
 
     def get_tool(self, tool_name: str) -> Callable:
@@ -278,7 +497,6 @@ class LightAgent:
         用于外部可以获取已加载的工具函数列表
         :return: 工具函数
         """
-
         return list(_FUNCTION_MAPPINGS.keys())
 
     def load_tools(self, tool_names: List[Union[str, Callable]], tools_directory: str = "tools"):
@@ -377,6 +595,18 @@ class LightAgent:
         elif level == "ERROR":
             self.logger.error(log_message)
 
+    async def setup_mcp(
+                        self,
+                        mcp_setting: dict | None = None,  # mcp 设置
+    ):
+        if mcp_setting:
+            self.mcp_setting = mcp_setting
+        """单独初始化 MCP 模块"""
+        if self.mcp_setting and not self.mcp_client:
+            self.mcp_client = MCPClientManager(self.mcp_setting)
+            await self.mcp_client.register_mcp_tool()
+            self.log("INFO", "setup_mcp", "MCP 模块初始化成功")
+
     def run(
             self,
             query: str,
@@ -489,18 +719,18 @@ class LightAgent:
                     fixed_args = function_call.arguments.replace('\\"', '"').replace('\\\\', '\\')
                     self.log("DEBUG", "non_stream function_call", {"function_call": fixed_args})
 
-                    function_args = json.loads(fixed_args)
                     # 解析函数参数
-                    # function_args = json.loads(function_call.arguments)
+                    function_args = json.loads(fixed_args)
 
                     # 调用工具并获取响应
-                    tool_response = dispatch_tool(function_call.name, function_args)
+                    tool_response = asyncio.run(dispatch_tool(function_call.name, function_args))
                     function_call_name = function_call.name
                     combined_response = ""
+                    single_tool_response = ""
 
                     # 如果工具返回的是生成器（流式输出），则将所有 chunk 叠加
                     if isinstance(tool_response, Generator):
-                        print(f"Streaming response from tool: {function_call.name}")
+                        # print(f"Streaming response from tool: {function_call.name}")
                         for chunk in tool_response:
                             # print("Received chunk:", chunk)  # 打印每个 chunk
                             if function_call_name == 'finish':
@@ -520,8 +750,8 @@ class LightAgent:
                         # 将 JSON 对象中的 Unicode 编码转换为中文字符
                         if isinstance(combined_response, dict):
                             combined_response = json.dumps(combined_response, ensure_ascii=False)  # 确保中文字符不转义
+                        single_tool_response = combined_response  # 处理单个工具的方法
 
-                        tool_responses.append(combined_response)  # 将叠加后的完整响应添加到列表
                     else:
                         # print(f"Non-streaming response from tool: {function_call.name}")
                         combined_response = tool_response
@@ -534,22 +764,23 @@ class LightAgent:
                             except json.JSONDecodeError:
                                 combined_response = tool_response
                                 pass  # 如果不是 JSON 字符串，保持原样
-                        tool_responses.append(combined_response)  # 直接添加普通响应
+                        single_tool_response = combined_response  # 处理单个工具的方法
 
-                    self.log("INFO", "non_stream tool_response", {"tool_response": combined_response})
+                    self.log("INFO", "non_stream single_tool_response", {"single_tool_response": single_tool_response})
 
-                    # 将工具调用的结果添加到列表中
-                    tool_responses.append(combined_response)
+                    # 将单个工具的响应结果添加到列表中
+                    tool_responses.append(single_tool_response)
 
                 # 将所有工具调用的结果合并为一个字符串
+                self.log("DEBUG", "non_stream tool_responses", {"tool_responses": tool_responses})
+
                 combined_tool_response = "\n".join(tool_responses)
 
                 # 将工具调用和响应添加到消息列表中
                 params["messages"].append(
                     {
                         "role": "assistant",
-                        "content": json.dumps(
-                            [tool_call.function.model_dump() for tool_call in tool_calls]),
+                        "content": f"使用工具： \n {json.dumps([tool_call.function.model_dump() for tool_call in tool_calls], ensure_ascii=False)}\n",
                     }
                 )
                 params["messages"].append(
@@ -561,14 +792,14 @@ class LightAgent:
             else:
                 # 返回最终回复
                 reply = response.choices[0].message.content
-                self.log("INFO", "final_reply", {"reply": reply})
+                self.log("INFO", "non_stream final_reply", {"reply": reply})
                 return reply
 
             # 更新响应
             if function_call_name == 'finish':
                 return  # 如果最后调用了finish工具，则结束生成器
             # print("params:",params)
-            self.log("DEBUG", "chat-completions params", {"params": params})
+            self.log("DEBUG", "non_stream chat-completions params", {"params": params})
 
             try:
                 response = self.client.chat.completions.create(**params)
@@ -631,7 +862,7 @@ class LightAgent:
                         chunk.choices[0].finish_reason == "stop" and any(
                     tool_call["name"] for tool_call in tool_calls)):
                     # 遍历所有工具调用
-                    self.log("DEBUG", "tool_calls", {"tool_calls": tool_calls})
+                    self.log("DEBUG", "stream tool_calls", {"tool_calls": tool_calls})
                     for tool_call in tool_calls:
                         if tool_call["name"]:  # 确保工具调用有名称
                             function_call = {
@@ -639,7 +870,7 @@ class LightAgent:
                                 "title": _FUNCTION_INFO.get(tool_call["name"], {}).get('tool_title') or '',
                                 "arguments": tool_call["arguments"],
                             }
-                            self.log("INFO", "tool_call", {"function_call": function_call})
+                            self.log("INFO", "stream function_call", {"function_call": function_call})
                             # 将工具的调用信息推送给开发者
                             yield function_call
 
@@ -655,14 +886,20 @@ class LightAgent:
                                 #     tool_responses.append(tool_response)
 
                                 for json_obj in json_objects:
-                                    function_args = json.loads(json_obj)
-                                    tool_response = dispatch_tool(function_call["name"], function_args)
+                                    # 尝试自动修复常见转义问题
+                                    fixed_args = json_obj.replace('\\"', '"').replace('\\\\', '\\')
+                                    self.log("DEBUG", "stream fixed_args", {"fixed_args": fixed_args})
+
+                                    function_args = json.loads(fixed_args)
+                                    # tool_response = dispatch_tool(function_call["name"], function_args)
+                                    tool_response = asyncio.run(dispatch_tool(function_call["name"], function_args))
                                     function_call_name = function_call["name"]
+                                    combined_response = ""
+                                    single_tool_response = ""
 
                                     # 如果工具返回的是生成器（流式输出），则将所有 chunk 叠加
                                     if isinstance(tool_response, Generator):
                                         # print(f"Streaming response from tool: {function_call['name']}")
-                                        combined_response = ""
                                         for chunk in tool_response:
                                             # 将工具返回的数据继续流出
                                             if isinstance(chunk, ChatCompletionChunk):
@@ -674,7 +911,7 @@ class LightAgent:
                                                         'tool_title') or '',
                                                     "output": chunk,
                                                 }
-                                                self.log("INFO", "tool_call", {"tool_output": tool_output})
+                                                self.log("DEBUG", "stream tool_output", {"tool_output": tool_output})
                                                 yield tool_output
                                             # 将工具的调用信息推送给开发者
                                             if function_call_name == 'finish':
@@ -682,13 +919,15 @@ class LightAgent:
                                                 combined_response += content  # 将每个 chunk 叠加
                                             else:
                                                 combined_response += chunk  # 将每个 chunk 叠加
-                                        tool_responses.append(combined_response)  # 将叠加后的完整响应添加到列表
+                                        single_tool_response = combined_response  # 处理单个工具的方法
                                     else:
                                         # print(f"Non-streaming response from tool: {tool_response}")
                                         combined_response = tool_response
-                                        tool_responses.append(combined_response)  # 直接添加普通响应
-                                    self.log("INFO", "stream tool_response", {"tool_response": combined_response})
-
+                                        single_tool_response = combined_response  # 处理单个工具的方法
+                                    self.log("INFO", "stream single_tool_response",
+                                             {"single_tool_response": single_tool_response})
+                                    # 将单个工具的响应结果添加到列表中
+                                    tool_responses.append(single_tool_response)
 
                             except json.JSONDecodeError as e:
                                 self.log("ERROR", "json_decode_error",
@@ -697,15 +936,15 @@ class LightAgent:
 
                     # 将所有工具调用的结果合并为一个字符串
                     combined_tool_response = "\n".join(tool_responses)
+                    tool_str = json.dumps(
+                        [{"name": tool_call["name"], "arguments": tool_call["arguments"]} for tool_call in tool_calls],
+                        ensure_ascii=False)
 
                     # 将工具调用和响应添加到消息列表中
                     params["messages"].append(
                         {
                             "role": "assistant",
-                            "content": json.dumps(
-                                [{"name": tool_call["name"], "arguments": tool_call["arguments"]} for tool_call in
-                                 tool_calls]
-                            ),
+                            "content": f"使用工具： \n {tool_str}\n"
                         }
                     )
                     params["messages"].append(
@@ -720,7 +959,7 @@ class LightAgent:
             # 更新响应
             if function_call_name == 'finish':
                 return  # 如果最后调用了finish工具，则结束生成器
-            self.log("DEBUG", "chat-completions params", {"params": params})
+            self.log("DEBUG", "stream chat-completions params", {"params": params})
             response = self.client.chat.completions.create(**params)
 
         # 重试次数用尽
@@ -1024,6 +1263,7 @@ class LightAgent:
 # 在函数内部定义工具信息
 get_weather.tool_info = {
     "tool_name": "get_weather",
+    "tool_title": "天气查询",
     "tool_description": "获取指定城市的当前天气信息",
     "tool_params": [
         {"name": "city_name", "description": "要查询的城市名称", "type": "string", "required": True},
@@ -1065,7 +1305,7 @@ get_weather.tool_info = {
                     f.write(tool_code)
                 self.log("INFO", "tool_created", {"tool_name": tool_name, "tool_path": tool_path})
 
-                # 加载新创建的工具
+                # 自动加载新创建的工具
                 self.load_tools([tool_name], tools_directory)
         except Exception as e:
             self.log("ERROR", "tool_creation_failed", {"error": str(e)})
@@ -1106,4 +1346,4 @@ class LightSwarm:
 if __name__ == "__main__":
     # Example of registering and using a tool
     print("This is LightAgent")
-    # print(dispatch_tool("example_tool", {"param1": "test"}))
+    # print(dispatch_tool("example_tool", {"param1": "test"}))

{lightagent-0.2.85 → lightagent-0.2.95}/PKG-INFO

@@ -1,20 +1,24 @@
 Metadata-Version: 2.1
 Name: LightAgent
-Version: 0.2.85
+Version: 0.2.95
 Summary: **LightAgent** is an extremely lightweight active Agentic Framework with memory (`mem0`), tools (`Tools`), and a Tree of Thought (`ToT`). It supports swarm-like multi-agent collaboration, automated tool generation, and agent assessment, with underlying model support for OpenAI, Zhipu ChatGLM, Baichuan Large Model, DeepSeek R1, Qwen series large models, and more. At the same time, LightAgent supports OpenAI streaming format API service output, seamlessly integrating with major mainstream chat frameworks. 🌟
 Home-page: https://github.com/wxai-space/LightAgent
 License: Apache 2.0
 Author: caiweige
 Author-email: caiweige@qq.com
-Requires-Python: >=3.10,<3.12
+Requires-Python: >=3.10,<3.13
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: colorama (==0.4.6)
 Requires-Dist: httpx (==0.28.1)
+Requires-Dist: httpx-sse (==0.4.0)
 Requires-Dist: loguru (==0.7.3)
+Requires-Dist: mcp (==1.5.0)
 Requires-Dist: openai (==1.59.3)
+Requires-Dist: pydantic-settings (==2.8.1)
 Requires-Dist: requests (==2.32.3)
 Project-URL: Repository, https://github.com/wxai-space/LightAgent
 Description-Content-Type: text/markdown
@@ -58,6 +62,8 @@ Description-Content-Type: text/markdown
 
 ---
 
+![lightswarm_demo_en.png](docs%2Fimages%2Flightswarm_demo_en.png)
+
 ## ✨ Features
 
 - **Lightweight and Efficient** 🚀: Minimalist design, quick deployment, suitable for various application scenarios. (No LangChain, No LlamaIndex) 100% Python implementation, no additional dependencies, core code is only 1000 lines, fully open source. 
@@ -74,7 +80,8 @@ Description-Content-Type: text/markdown
 
 ---
 ## News
-- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.2.7  supports deepseek-r1 model for tot now.Significantly enhances the multi-tool planning capability for complex tasks.
+- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.3.0 fully supports the MCP protocol, enabling collaborative work with multiple models and tools to achieve more efficient handling of complex tasks.<a href="mcp_release.zh-CN.md">View MCP release introduction.>></a>
+- **[2025-02-19]** LightAgent v0.2.7  supports deepseek-r1 model for tot now.Significantly enhances the multi-tool planning capability for complex tasks.
 - **[2025-02-06]** LightAgent version 0.2.5 is released now.
 - **[2025-01-20]** LightAgent version 0.2.0 is released now.
 - **[2025-01-05]** LightAgent version 0.1.0 is released now.
@@ -776,7 +783,7 @@ We look forward to your feedback and work together to make LightAgent even stron
 **LightAgent** 是一个极其轻量的带记忆（`mem0`）、工具（`Tools`）、思维树（`ToT`）的主动式 Agentic Framework（自主性框架）。它支持比Openai Swarm更简单的多智能体协同，构建具备自我学习能力的agent，并支持Agent测评，底层模型支持 OpenAI、智谱 ChatGLM、DeepSeek、阶跃星辰、Qwen通义千问大模型等。同时，LightAgent 支持 OpenAI 流格式 API 服务输出，无缝接入各大主流 Chat 框架。🌟
 
 ---
-
+![lightswarm_demo_cn.png](docs%2Fimages%2Flightswarm_demo_cn.png)
 ## ✨ 特性
 
 - **轻量高效** 🚀：极简设计，快速部署，适合各种规模的应用场景。（No LangChain, No LlamaIndex）100% Python 实现，无需额外依赖，核心代码仅1000行，完全开源。 
@@ -793,7 +800,8 @@ We look forward to your feedback and work together to make LightAgent even stron
 
 ---
 ## 新闻
-- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.2.7 支持单独采用 deepseek-r1 作为的agent推理规划ToT引擎，大幅度提升复杂任务的多工具Plan能力.
+- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.3.0 全面支持MCP协议，支持多模型多工具的协同工作，实现更高效的复杂任务处理。<a href="mcp_release.zh-CN.md">查看MCP发布简介>></a>
+- **[2025-02-19]** LightAgent v0.2.7 支持单独采用 deepseek-r1 作为的agent推理规划ToT引擎，大幅度提升复杂任务的多工具Plan能力.
 - **[2025-02-06]** LightAgent version 0.2.5 is released now.
 - **[2025-01-20]** LightAgent version 0.2.0 is released now.
 - **[2025-01-05]** LightAgent version 0.1.0 is released now.

{lightagent-0.2.85 → lightagent-0.2.95}/README.md

@@ -37,6 +37,8 @@
 
 ---
 
+![lightswarm_demo_en.png](docs%2Fimages%2Flightswarm_demo_en.png)
+
 ## ✨ Features
 
 - **Lightweight and Efficient** 🚀: Minimalist design, quick deployment, suitable for various application scenarios. (No LangChain, No LlamaIndex) 100% Python implementation, no additional dependencies, core code is only 1000 lines, fully open source. 
@@ -53,7 +55,8 @@
 
 ---
 ## News
-- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.2.7  supports deepseek-r1 model for tot now.Significantly enhances the multi-tool planning capability for complex tasks.
+- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.3.0 fully supports the MCP protocol, enabling collaborative work with multiple models and tools to achieve more efficient handling of complex tasks.<a href="mcp_release.zh-CN.md">View MCP release introduction.>></a>
+- **[2025-02-19]** LightAgent v0.2.7  supports deepseek-r1 model for tot now.Significantly enhances the multi-tool planning capability for complex tasks.
 - **[2025-02-06]** LightAgent version 0.2.5 is released now.
 - **[2025-01-20]** LightAgent version 0.2.0 is released now.
 - **[2025-01-05]** LightAgent version 0.1.0 is released now.

{lightagent-0.2.85 → lightagent-0.2.95}/README.zh-CN.md

@@ -36,7 +36,7 @@
 **LightAgent** 是一个极其轻量的带记忆（`mem0`）、工具（`Tools`）、思维树（`ToT`）的主动式 Agentic Framework（自主性框架）。它支持比Openai Swarm更简单的多智能体协同，构建具备自我学习能力的agent，并支持Agent测评，底层模型支持 OpenAI、智谱 ChatGLM、DeepSeek、阶跃星辰、Qwen通义千问大模型等。同时，LightAgent 支持 OpenAI 流格式 API 服务输出，无缝接入各大主流 Chat 框架。🌟
 
 ---
-
+![lightswarm_demo_cn.png](docs%2Fimages%2Flightswarm_demo_cn.png)
 ## ✨ 特性
 
 - **轻量高效** 🚀：极简设计，快速部署，适合各种规模的应用场景。（No LangChain, No LlamaIndex）100% Python 实现，无需额外依赖，核心代码仅1000行，完全开源。 
@@ -53,7 +53,8 @@
 
 ---
 ## 新闻
-- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.2.7 支持单独采用 deepseek-r1 作为的agent推理规划ToT引擎，大幅度提升复杂任务的多工具Plan能力.
+- <img src="https://img.alicdn.com/imgextra/i3/O1CN01SFL0Gu26nrQBFKXFR_!!6000000007707-2-tps-500-500.png" alt="new" width="30" height="30"/>**[2025-02-19]** LightAgent v0.3.0 全面支持MCP协议，支持多模型多工具的协同工作，实现更高效的复杂任务处理。<a href="mcp_release.zh-CN.md">查看MCP发布简介>></a>
+- **[2025-02-19]** LightAgent v0.2.7 支持单独采用 deepseek-r1 作为的agent推理规划ToT引擎，大幅度提升复杂任务的多工具Plan能力.
 - **[2025-02-06]** LightAgent version 0.2.5 is released now.
 - **[2025-01-20]** LightAgent version 0.2.0 is released now.
 - **[2025-01-05]** LightAgent version 0.1.0 is released now.

{lightagent-0.2.85 → lightagent-0.2.95}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "LightAgent"
-version = "0.2.85"
+version = "0.2.95"
 description = "**LightAgent** is an extremely lightweight active Agentic Framework with memory (`mem0`), tools (`Tools`), and a Tree of Thought (`ToT`). It supports swarm-like multi-agent collaboration, automated tool generation, and agent assessment, with underlying model support for OpenAI, Zhipu ChatGLM, Baichuan Large Model, DeepSeek R1, Qwen series large models, and more. At the same time, LightAgent supports OpenAI streaming format API service output, seamlessly integrating with major mainstream chat frameworks. 🌟"
 authors = ["caiweige <caiweige@qq.com>"]
 license = "Apache 2.0"
@@ -22,12 +22,16 @@ packages = [
 
 
 [tool.poetry.dependencies]
-python = ">=3.10,<3.12,!=3.9.7"
+python = ">=3.10,<3.13,!=3.9.7"
 loguru = "0.7.3"
 requests = "2.32.3"
 openai = "1.59.3"
 colorama = "0.4.6"
 httpx = "0.28.1"
+httpx-sse = "0.4.0"
+mcp = "1.5.0"
+pydantic-settings = "2.8.1"
+
 
 [tool.ruff]
 extend-include = ["*.ipynb"]