agentica 0.2.5__tar.gz → 1.0.1__tar.gz

{agentica-0.2.5/agentica.egg-info → agentica-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: agentica
-Version: 0.2.5
+Version: 1.0.1
 Summary: LLM agents
 Home-page: https://github.com/shibing624/agentica
 Author: XuMing
@@ -15,7 +15,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8.0
+Requires-Python: >=3.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx
@@ -31,6 +31,7 @@ Requires-Dist: markdownify
 Requires-Dist: tqdm
 Requires-Dist: rich
 Requires-Dist: pyyaml
+Requires-Dist: mcp
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -39,6 +40,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -70,26 +72,9 @@ Dynamic: summary
 
 **Agentica** 可以构建AI Agent，包括规划、记忆和工具使用、执行等组件。
 
-#### Agent Components
-<img src="https://github.com/shibing624/agentica/blob/main/docs/llm_agentv2.png" width="800" />
-
-- **规划（Planning）**：任务拆解、生成计划、反思
-- **记忆（Memory）**：短期记忆（prompt实现）、长期记忆（RAG实现）
-- **工具使用（Tool use）**：function call能力，调用外部API，以获取外部信息，包括当前日期、日历、代码执行能力、对专用信息源的访问等
-
-#### Agentica Workflow
-
-**Agentica** can also build multi-agent systems and workflows.
-
-**Agentica** 还可以构建多Agent系统和工作流。
-
-<img src="https://github.com/shibing624/agentica/blob/main/docs/agent_arch.png" width="800" />
-
-- **Planner**：负责让LLM生成一个多步计划来完成复杂任务，生成相互依赖的“链式计划”，定义每一步所依赖的上一步的输出
-- **Worker**：接受“链式计划”，循环遍历计划中的每个子任务，并调用工具完成任务，可以自动反思纠错以完成任务
-- **Solver**：求解器将所有这些输出整合为最终答案
-
 ## 🔥 News
+[2025/04/21] v1.0.0版本：支持了`MCP`的工具调用，兼容SSE和Stdio两种MCP Server，详见[Release-v1.0.0](https://github.com/shibing624/agentica/releases/tag/1.0.0)
+
 [2024/12/29] v0.2.3版本: 支持了`ZhipuAI`的api调用，包括免费模型和工具使用，详见[Release-v0.2.3](https://github.com/shibing624/agentica/releases/tag/0.2.3)
 
 [2024/12/25] v0.2.0版本: 支持了多模态模型，输入可以是文本、图片、音频、视频，升级Assistant为Agent，Workflow支持拆解并实现复杂任务，详见[Release-v0.2.0](https://github.com/shibing624/agentica/releases/tag/0.2.0)
@@ -101,10 +86,10 @@ Dynamic: summary
 `Agentica`是一个用于构建Agent的工具，具有以下功能：
 
 - **Agent编排**：通过简单代码快速编排Agent，支持 Reflection(反思）、Plan and Solve(计划并执行)、RAG、Agent、Multi-Agent、Team、Workflow等功能
-- **自定义prompt**：Agent支持自定义prompt和多种工具调用（tool_calls）
+- **工具调用**：支持自定义工具OpenAI的function call，支持MCP Server的工具调用
 - **LLM集成**：支持OpenAI、Azure、Deepseek、Moonshot、Anthropic、ZhipuAI、Ollama、Together等多方大模型厂商的API
-- **记忆功能**：包括短期记忆和长期记忆功能
-- **Multi-Agent协作**：支持多Agent和任务委托（Team）的团队协作。
+- **记忆功能**：支持短期记忆和长期记忆功能
+- **Multi-Agent协作**：支持多Agent和任务委托（Team）的团队协作
 - **Workflow工作流**：拆解复杂任务为多个Agent，基于工作流自动化串行逐步完成任务，如投资研究、新闻文章撰写和技术教程创建
 - **自我进化Agent**：具有反思和增强记忆能力的自我进化Agent
 - **Web UI**：兼容ChatPilot，可以基于Web页面交互，支持主流的open-webui、streamlit、gradio等前端交互框架
@@ -134,10 +119,10 @@ cd examples
 python 12_web_search_moonshot_demo.py
 ```
 
-1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填DEEPSEEK_API_KEY、MOONSHOT_API_KEY、OPENAI_API_KEY、ZHIPUAI_API_KEY等任一个即可)。或者使用`export`命令设置环境变量：
+1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填OPENAI_API_KEY、ZHIPUAI_API_KEY 等任一个)。或者使用`export`命令设置环境变量：
     
     ```shell
-    export MOONSHOT_API_KEY=your_moonshot_api_key
+    export ZHIPUAI_API_KEY=your_api_key
     export SERPER_API_KEY=your_serper_api_key
     ```
 
@@ -228,6 +213,8 @@ bash start.sh
 | [examples/38_workflow_write_tutorial_demo.py](https://github.com/shibing624/agentica/blob/main/examples/38_workflow_write_tutorial_demo.py)           | 实现了写技术教程的工作流：定教程目录 - 反思目录内容 - 撰写教程内容 - 保存为md文件                                                                                    |
 | [examples/39_audio_multi_turn_demo.py](https://github.com/shibing624/agentica/blob/main/examples/39_audio_multi_turn_demo.py)                         | 基于openai的语音api做多轮音频对话的Demo                                                                                                        |
 | [examples/40_weather_zhipuai_demo.py](https://github.com/shibing624/agentica/blob/main/examples/40_web_search_zhipuai_demo.py)                        | 基于智谱AI的api做天气查询的Demo                                                                                                              |
+| [examples/41_mcp_stdio_demo.py](https://github.com/shibing624/agentica/blob/main/examples/41_mcp_stdio_demo.py)                                       | Stdio的MCP Server调用的Demo                                                                                                           |
+| [examples/42_mcp_sse_client.py](https://github.com/shibing624/agentica/blob/main/examples/42_mcp_sse_client.py)                                       | SSE的MCP Server调用的Demo                                                                                                             |
 
 
 ### Self-evolving Agent

{agentica-0.2.5 → agentica-1.0.1}/README.md

@@ -25,26 +25,9 @@
 
 **Agentica** 可以构建AI Agent，包括规划、记忆和工具使用、执行等组件。
 
-#### Agent Components
-<img src="https://github.com/shibing624/agentica/blob/main/docs/llm_agentv2.png" width="800" />
-
-- **规划（Planning）**：任务拆解、生成计划、反思
-- **记忆（Memory）**：短期记忆（prompt实现）、长期记忆（RAG实现）
-- **工具使用（Tool use）**：function call能力，调用外部API，以获取外部信息，包括当前日期、日历、代码执行能力、对专用信息源的访问等
-
-#### Agentica Workflow
-
-**Agentica** can also build multi-agent systems and workflows.
-
-**Agentica** 还可以构建多Agent系统和工作流。
-
-<img src="https://github.com/shibing624/agentica/blob/main/docs/agent_arch.png" width="800" />
-
-- **Planner**：负责让LLM生成一个多步计划来完成复杂任务，生成相互依赖的“链式计划”，定义每一步所依赖的上一步的输出
-- **Worker**：接受“链式计划”，循环遍历计划中的每个子任务，并调用工具完成任务，可以自动反思纠错以完成任务
-- **Solver**：求解器将所有这些输出整合为最终答案
-
 ## 🔥 News
+[2025/04/21] v1.0.0版本：支持了`MCP`的工具调用，兼容SSE和Stdio两种MCP Server，详见[Release-v1.0.0](https://github.com/shibing624/agentica/releases/tag/1.0.0)
+
 [2024/12/29] v0.2.3版本: 支持了`ZhipuAI`的api调用，包括免费模型和工具使用，详见[Release-v0.2.3](https://github.com/shibing624/agentica/releases/tag/0.2.3)
 
 [2024/12/25] v0.2.0版本: 支持了多模态模型，输入可以是文本、图片、音频、视频，升级Assistant为Agent，Workflow支持拆解并实现复杂任务，详见[Release-v0.2.0](https://github.com/shibing624/agentica/releases/tag/0.2.0)
@@ -56,10 +39,10 @@
 `Agentica`是一个用于构建Agent的工具，具有以下功能：
 
 - **Agent编排**：通过简单代码快速编排Agent，支持 Reflection(反思）、Plan and Solve(计划并执行)、RAG、Agent、Multi-Agent、Team、Workflow等功能
-- **自定义prompt**：Agent支持自定义prompt和多种工具调用（tool_calls）
+- **工具调用**：支持自定义工具OpenAI的function call，支持MCP Server的工具调用
 - **LLM集成**：支持OpenAI、Azure、Deepseek、Moonshot、Anthropic、ZhipuAI、Ollama、Together等多方大模型厂商的API
-- **记忆功能**：包括短期记忆和长期记忆功能
-- **Multi-Agent协作**：支持多Agent和任务委托（Team）的团队协作。
+- **记忆功能**：支持短期记忆和长期记忆功能
+- **Multi-Agent协作**：支持多Agent和任务委托（Team）的团队协作
 - **Workflow工作流**：拆解复杂任务为多个Agent，基于工作流自动化串行逐步完成任务，如投资研究、新闻文章撰写和技术教程创建
 - **自我进化Agent**：具有反思和增强记忆能力的自我进化Agent
 - **Web UI**：兼容ChatPilot，可以基于Web页面交互，支持主流的open-webui、streamlit、gradio等前端交互框架
@@ -89,10 +72,10 @@ cd examples
 python 12_web_search_moonshot_demo.py
 ```
 
-1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填DEEPSEEK_API_KEY、MOONSHOT_API_KEY、OPENAI_API_KEY、ZHIPUAI_API_KEY等任一个即可)。或者使用`export`命令设置环境变量：
+1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填OPENAI_API_KEY、ZHIPUAI_API_KEY 等任一个)。或者使用`export`命令设置环境变量：
     
     ```shell
-    export MOONSHOT_API_KEY=your_moonshot_api_key
+    export ZHIPUAI_API_KEY=your_api_key
     export SERPER_API_KEY=your_serper_api_key
     ```
 
@@ -183,6 +166,8 @@ bash start.sh
 | [examples/38_workflow_write_tutorial_demo.py](https://github.com/shibing624/agentica/blob/main/examples/38_workflow_write_tutorial_demo.py)           | 实现了写技术教程的工作流：定教程目录 - 反思目录内容 - 撰写教程内容 - 保存为md文件                                                                                    |
 | [examples/39_audio_multi_turn_demo.py](https://github.com/shibing624/agentica/blob/main/examples/39_audio_multi_turn_demo.py)                         | 基于openai的语音api做多轮音频对话的Demo                                                                                                        |
 | [examples/40_weather_zhipuai_demo.py](https://github.com/shibing624/agentica/blob/main/examples/40_web_search_zhipuai_demo.py)                        | 基于智谱AI的api做天气查询的Demo                                                                                                              |
+| [examples/41_mcp_stdio_demo.py](https://github.com/shibing624/agentica/blob/main/examples/41_mcp_stdio_demo.py)                                       | Stdio的MCP Server调用的Demo                                                                                                           |
+| [examples/42_mcp_sse_client.py](https://github.com/shibing624/agentica/blob/main/examples/42_mcp_sse_client.py)                                       | SSE的MCP Server调用的Demo                                                                                                             |
 
 
 ### Self-evolving Agent

{agentica-0.2.5 → agentica-1.0.1}/agentica/agent.py

@@ -2055,7 +2055,7 @@ class Agent(BaseModel):
         self.run_id = str(uuid4())
         self.run_response = RunResponse(run_id=self.run_id, session_id=self.session_id, agent_id=self.agent_id)
 
-        logger.debug(f"*********** Async Agent Run Start: {self.run_response.run_id} ***********")
+        logger.debug(f"*********** Agent Run Start: {self.run_response.run_id} ***********")
 
         # 1. Update the Model (set defaults, add tools, etc.)
         self.update_model()
@@ -2227,10 +2227,7 @@ class Agent(BaseModel):
         elif messages is not None:
             self.run_input = [m.to_dict() if isinstance(m, Message) else m for m in messages]
 
-        # Log Agent Run
-        await self.alog_agent_run()
-
-        logger.debug(f"*********** Async Agent Run End: {self.run_response.run_id} ***********")
+        logger.debug(f"*********** Agent Run End: {self.run_response.run_id} ***********")
         if self.stream_intermediate_steps:
             yield self.generic_run_response(
                 content=self.run_response.content,

{agentica-0.2.5 → agentica-1.0.1}/agentica/config.py

@@ -9,6 +9,7 @@ from dotenv import load_dotenv  # noqa
 from loguru import logger  # noqa, need to import logger here to avoid circular import
 
 AGENTICA_HOME = os.getenv("AGENTICA_HOME", os.path.expanduser("~/.agentica"))
+os.makedirs(AGENTICA_HOME, exist_ok=True)
 
 # Load environment variables from .env file
 AGENTICA_DOTENV_PATH = os.getenv("AGENTICA_DOTENV_PATH", f"{AGENTICA_HOME}/.env")

agentica-1.0.1/agentica/mcp/__init__.py

@@ -0,0 +1,20 @@
+try:
+    from .server import (
+        MCPServer,
+        MCPServerSse,
+        MCPServerSseParams,
+        MCPServerStdio,
+        MCPServerStdioParams,
+    )
+    from .client import MCPClient
+except ImportError:
+    pass
+
+__all__ = [
+    "MCPServer",
+    "MCPServerSse",
+    "MCPServerSseParams",
+    "MCPServerStdio",
+    "MCPServerStdioParams",
+    "MCPClient",
+]

agentica-1.0.1/agentica/mcp/client.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description: 
+"""
+
+from typing import Any, Dict, List, Optional
+from mcp import Tool as MCPTool
+from mcp.types import CallToolResult, EmbeddedResource, ImageContent, TextContent
+from agentica.mcp.server import MCPServer
+from agentica.utils.log import logger
+
+__all__ = ["MCPClient"]
+
+
+class MCPClient:
+    """A client for interacting with MCP servers.
+
+    This client can be used as an async context manager to automatically manage connections
+    and resource cleanup.
+
+    Example:
+    ```python
+    # For stdio-based server
+    params = MCPServerStdioParams(command="python", args=["server.py"])
+    async with MCPClient(server=MCPServerStdio(params)) as client:
+        result = await client.call_tool("add", {"a": 1, "b": 2})
+        print(result)
+
+    # For SSE-based server
+    params = MCPServerSseParams(url="http://localhost:8000/sse")
+    async with MCPClient(server=MCPServerSse(params)) as client:
+        result = await client.call_tool("get_weather", {"city": "Tokyo"})
+        print(result)
+    ```
+    """
+
+    def __init__(
+            self,
+            server: MCPServer,
+            include_tools: Optional[List[str]] = None,
+            exclude_tools: Optional[List[str]] = None
+    ):
+        """Initialize the MCP client.
+
+        Args:
+            server: The MCP server to connect to
+            include_tools: Optional list of tool names to include (if None, includes all)
+            exclude_tools: Optional list of tool names to exclude (if None, excludes none)
+        """
+        self.server = server
+        self.tools_list: List[MCPTool] = []
+        self.tools_by_name: Dict[str, MCPTool] = {}
+        self.include_tools = include_tools
+        self.exclude_tools = exclude_tools or []
+
+    async def __aenter__(self) -> 'MCPClient':
+        """Enter the async context manager."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        """Exit the async context manager."""
+        await self.cleanup()
+
+    async def connect(self) -> None:
+        """Connect to the MCP server and retrieve the list of available tools."""
+        logger.info(f"Connecting to MCP server: {self.server.name}")
+
+        try:
+            await self.server.connect()
+
+            # Get the list of tools from the MCP server
+            all_tools = await self.server.list_tools()
+
+            # Filter tools based on include/exclude lists
+            self.tools_list = []
+            for tool in all_tools:
+                if tool.name in self.exclude_tools:
+                    continue
+                if self.include_tools is None or tool.name in self.include_tools:
+                    self.tools_list.append(tool)
+
+            # Create a mapping of tool names to tools
+            self.tools_by_name = {tool.name: tool for tool in self.tools_list}
+
+            logger.info(f"Connected to {self.server.name} with {len(self.tools_list)} tools available")
+            for tool in self.tools_list:
+                logger.debug(f"  - {tool.name}: {tool.description or 'No description'}")
+
+        except Exception as e:
+            logger.error(f"Error connecting to MCP server: {e}")
+            await self.cleanup()
+            raise
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any] = None) -> Any:
+        """Call a tool on the MCP server.
+
+        Args:
+            tool_name: The name of the tool to call
+            arguments: The arguments to pass to the tool
+
+        Returns:
+            The result of the tool call
+
+        Raises:
+            ValueError: If the tool is not available
+        """
+        if tool_name not in self.tools_by_name:
+            available_tools = ", ".join(self.tools_by_name.keys())
+            raise ValueError(f"Tool '{tool_name}' not available. Available tools: {available_tools}")
+        logger.debug(f"Calling tool '{tool_name}' with arguments: {arguments}")
+        try:
+            result = await self.server.call_tool(tool_name, arguments)
+            return result
+        except Exception as e:
+            msg = f"Error calling tool '{tool_name}': {e}"
+            logger.error(msg)
+            return msg
+
+    def extract_result_text(self, result: CallToolResult) -> str:
+        """Extract text content from a tool call result.
+
+        Args:
+            result: The result from a tool call
+
+        Returns:
+            The extracted text content
+        """
+        if result.isError:
+            return f"Error: {result.content}"
+
+        text_parts = []
+        for content_item in result.content:
+            if isinstance(content_item, TextContent):
+                text_parts.append(content_item.text)
+            elif isinstance(content_item, ImageContent):
+                text_parts.append(f"[Image content: {content_item.data}]")
+            elif isinstance(content_item, EmbeddedResource):
+                text_parts.append(f"[Embedded resource: {content_item.resource.model_dump_json()}]")
+            else:
+                text_parts.append(f"[Unsupported content type: {content_item.type}]")
+
+        return "\n".join(text_parts)
+
+    async def list_tools(self) -> List[MCPTool]:
+        """List the available tools.
+
+        Returns:
+            List of available tools
+        """
+        return self.tools_list
+
+    async def cleanup(self) -> None:
+        """Clean up resources and close the connection."""
+        try:
+            await self.server.cleanup()
+            logger.debug(f"Disconnected from MCP server: {self.server.name}")
+        except Exception as e:
+            logger.error(f"Error cleaning up MCP client: {e}")

agentica-1.0.1/agentica/mcp/server.py

@@ -0,0 +1,293 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description: Model Context Protocol (MCP) client implementations supporting both stdio and SSE transports
+"""
+from __future__ import annotations
+
+import abc
+import asyncio
+from contextlib import AbstractAsyncContextManager, AsyncExitStack
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict, Union
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp import ClientSession, StdioServerParameters, Tool as MCPTool, stdio_client
+from mcp.client.sse import sse_client
+from mcp.types import CallToolResult, JSONRPCMessage
+
+from agentica.utils.log import logger
+
+
+class MCPServer(abc.ABC):
+    """Base class for Model Context Protocol servers."""
+
+    @abc.abstractmethod
+    async def connect(self):
+        """Connect to the server. For example, this might mean spawning a subprocess or
+        opening a network connection. The server is expected to remain connected until
+        `cleanup()` is called.
+        """
+        pass
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """A readable name for the server."""
+        pass
+
+    @abc.abstractmethod
+    async def cleanup(self):
+        """Cleanup the server. For example, this might mean closing a subprocess or
+        closing a network connection.
+        """
+        pass
+
+    @abc.abstractmethod
+    async def list_tools(self) -> List[MCPTool]:
+        """List the tools available on the server."""
+        pass
+
+    @abc.abstractmethod
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any] | None) -> CallToolResult:
+        """Invoke a tool on the server."""
+        pass
+
+
+class _MCPServerWithClientSession(MCPServer, abc.ABC):
+    """Base class for MCP servers that use a `ClientSession` to communicate with the server."""
+
+    def __init__(self, cache_tools_list: bool = True):
+        """
+        Args:
+            cache_tools_list: Whether to cache the tools list. If `True`, the tools list will be
+                cached and only fetched from the server once. If `False`, the tools list will be
+                fetched from the server on each call to `list_tools()`. The cache can be invalidated
+                by calling `invalidate_tools_cache()`. You should set this to `True` if you know the
+                server will not change its tools list, because it can drastically improve latency
+                (by avoiding a round-trip to the server every time).
+        """
+        self.session: Optional[ClientSession] = None
+        self.exit_stack: AsyncExitStack = AsyncExitStack()
+        self._cleanup_lock: asyncio.Lock = asyncio.Lock()
+        self.cache_tools_list = cache_tools_list
+
+        # The cache is always dirty at startup, so that we fetch tools at least once
+        self._cache_dirty = True
+        self._tools_list: Optional[List[MCPTool]] = None
+
+    @abc.abstractmethod
+    def create_streams(
+            self,
+    ) -> AbstractAsyncContextManager[
+        Tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
+    ]:
+        """Create the streams for the server."""
+        pass
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.cleanup()
+
+    def invalidate_tools_cache(self):
+        """Invalidate the tools cache."""
+        self._cache_dirty = True
+
+    async def connect(self):
+        """Connect to the server."""
+        try:
+            transport = await self.exit_stack.enter_async_context(self.create_streams())
+            read, write = transport
+            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            self.session = session
+        except Exception as e:
+            logger.error(f"Error initializing MCP server: {e}")
+            await self.cleanup()
+            raise
+
+    async def list_tools(self) -> List[MCPTool]:
+        """List the tools available on the server."""
+        if not self.session:
+            raise ValueError("Server not initialized. Make sure you call `connect()` first.")
+
+        # Return from cache if caching is enabled, we have tools, and the cache is not dirty
+        if self.cache_tools_list and not self._cache_dirty and self._tools_list:
+            return self._tools_list
+
+        # Reset the cache dirty to False
+        self._cache_dirty = False
+
+        # Fetch the tools from the server
+        self._tools_list = (await self.session.list_tools()).tools
+        return self._tools_list
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any] | None) -> CallToolResult:
+        """Invoke a tool on the server."""
+        if not self.session:
+            raise ValueError("Server not initialized. Make sure you call `connect()` first.")
+
+        return await self.session.call_tool(tool_name, arguments)
+
+    async def cleanup(self):
+        """Cleanup the server."""
+        async with self._cleanup_lock:
+            try:
+                await self.exit_stack.aclose()
+                self.session = None
+            except Exception as e:
+                logger.error(f"Error cleaning up server: {e}")
+
+
+class MCPServerStdioParams(TypedDict):
+    """Parameters for the MCPServerStdio class."""
+    command: str
+    """The executable to run to start the server. For example, `python` or `node`."""
+
+    args: Optional[List[str]]
+    """Command line args to pass to the `command` executable. For example, `['foo.py']` or
+    `['server.js', '--port', '8080']`."""
+
+    env: Optional[Dict[str, str]]
+    """The environment variables to set for the server."""
+
+    cwd: Optional[Union[str, Path]]
+    """The working directory to use when spawning the process."""
+
+    encoding: Optional[str]
+    """The text encoding used when sending/receiving messages to the server. Defaults to `utf-8`."""
+
+    encoding_error_handler: Optional[Literal["strict", "ignore", "replace"]]
+    """The text encoding error handler. Defaults to `strict`.
+    See https://docs.python.org/3/library/codecs.html#codec-base-classes for
+    explanations of possible values.
+    """
+
+
+class MCPServerStdio(_MCPServerWithClientSession):
+    """MCP server implementation that uses the stdio transport.
+
+    See the specification for details: https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio
+    """
+
+    def __init__(
+            self,
+            params: MCPServerStdioParams,
+            cache_tools_list: bool = True,
+            name: Optional[str] = None,
+    ):
+        """Create a new MCP server based on the stdio transport.
+
+        Args:
+            params: The params that configure the server. This includes the command to run to
+                start the server, the args to pass to the command, the environment variables to
+                set for the server, the working directory to use when spawning the process, and
+                the text encoding used when sending/receiving messages to the server.
+            cache_tools_list: Whether to cache the tools list. If `True`, the tools list will be
+                cached and only fetched from the server once. If `False`, the tools list will be
+                fetched from the server on each call to `list_tools()`. The cache can be
+                invalidated by calling `invalidate_tools_cache()`. You should set this to `True`
+                if you know the server will not change its tools list, because it can drastically
+                improve latency (by avoiding a round-trip to the server every time).
+            name: A readable name for the server. If not provided, we'll create one from the
+                command.
+        """
+        super().__init__(cache_tools_list)
+        self.params = StdioServerParameters(
+            command=params["command"],
+            args=params.get("args", []),
+            env=params.get("env"),
+            cwd=params.get("cwd"),
+            encoding=params.get("encoding", "utf-8"),
+            encoding_error_handler=params.get("encoding_error_handler", "strict"),
+        )
+        self._name = name or f"stdio: {self.params.command}"
+
+    def create_streams(
+            self,
+    ) -> AbstractAsyncContextManager[
+        Tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
+    ]:
+        """Create the streams for the server."""
+        return stdio_client(self.params)
+
+    @property
+    def name(self) -> str:
+        """A readable name for the server."""
+        return self._name
+
+
+class MCPServerSseParams(TypedDict):
+    """Parameters for the MCPServerSse class."""
+    url: str
+    """The URL of the server."""
+
+    headers: Optional[Dict[str, str]]
+    """The headers to send to the server."""
+
+    timeout: Optional[float]
+    """The timeout for the HTTP request. Defaults to 5 seconds."""
+
+    sse_read_timeout: Optional[float]
+    """The timeout for the SSE connection, in seconds. Defaults to 5 minutes."""
+
+
+class MCPServerSse(_MCPServerWithClientSession):
+    """MCP server implementation that uses the HTTP with SSE transport.
+
+    See the specification for details: https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse
+    """
+
+    def __init__(
+            self,
+            params: MCPServerSseParams,
+            cache_tools_list: bool = True,
+            name: Optional[str] = None,
+    ):
+        """Create a new MCP server based on the HTTP with SSE transport.
+
+        Args:
+            params: The params that configure the server. This includes the URL of the server,
+                the headers to send to the server, the timeout for the HTTP request, and the
+                timeout for the SSE connection.
+            cache_tools_list: Whether to cache the tools list. If `True`, the tools list will be
+                cached and only fetched from the server once. If `False`, the tools list will be
+                fetched from the server on each call to `list_tools()`. The cache can be
+                invalidated by calling `invalidate_tools_cache()`. You should set this to `True`
+                if you know the server will not change its tools list, because it can drastically
+                improve latency (by avoiding a round-trip to the server every time).
+            name: A readable name for the server. If not provided, we'll create one from the
+                URL.
+        """
+        super().__init__(cache_tools_list)
+        self.params = params
+        self._name = name or f"sse: {self.params['url']}"
+
+    def create_streams(
+            self,
+    ) -> AbstractAsyncContextManager[
+        Tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
+    ]:
+        """Create the streams for the server."""
+        return sse_client(
+            url=self.params["url"],
+            headers=self.params.get("headers"),
+            timeout=self.params.get("timeout", 5),
+            sse_read_timeout=self.params.get("sse_read_timeout", 60 * 5),
+        )
+
+    @property
+    def name(self) -> str:
+        """A readable name for the server."""
+        return self._name