lionagi 0.17.2__py3-none-any.whl → 0.17.4__py3-none-any.whl

lionagi/__init__.py

@@ -6,7 +6,6 @@ import logging
 
 from pydantic import BaseModel, Field
 
-# Eager imports for commonly used components
 from . import ln as ln
 from .operations.node import Operation
 from .service.imodel import iModel
@@ -35,6 +34,11 @@ def __getattr__(name: str):
 
         _lazy_imports["Builder"] = Builder
         return Builder
+    elif name == "load_mcp_tools":
+        from .protocols.action.manager import load_mcp_tools
+
+        _lazy_imports["load_mcp_tools"] = load_mcp_tools
+        return load_mcp_tools
 
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 

lionagi/protocols/action/manager.py

@@ -12,8 +12,6 @@ from lionagi.utils import to_list
 from .function_calling import FunctionCalling
 from .tool import FuncTool, FuncToolRef, Tool, ToolRef
 
-__all__ = ("ActionManager",)
-
 
 class ActionManager(Manager):
     """
@@ -67,13 +65,16 @@ class ActionManager(Manager):
 
         Args:
             tool (FuncTool):
-                A `Tool` object or a raw callable function.
+                A `Tool` object, a raw callable function, or an MCP config dict.
+                - Tool: Registered directly
+                - Callable: Wrapped as Tool(func_callable=...)
+                - Dict: Treated as MCP config, Tool(mcp_config=...)
             update (bool):
                 If True, allow replacing an existing tool with the same name.
 
         Raises:
             ValueError: If tool already registered and update=False.
-            TypeError: If `tool` is not a Tool or callable.
+            TypeError: If `tool` is not a Tool, callable, or dict.
         """
         # Check if tool already exists
         if not update and tool in self:
@@ -82,14 +83,20 @@ class ActionManager(Manager):
                 name = tool.function
             elif callable(tool):
                 name = tool.__name__
+            elif isinstance(tool, dict):
+                # For MCP config, extract the tool name (first key)
+                name = list(tool.keys())[0] if tool else None
             raise ValueError(f"Tool {name} is already registered.")
 
-        # Convert raw callable to a Tool if needed
+        # Convert to Tool object based on type
         if callable(tool):
             tool = Tool(func_callable=tool)
-        if not isinstance(tool, Tool):
+        elif isinstance(tool, dict):
+            # Dict is treated as MCP config
+            tool = Tool(mcp_config=tool)
+        elif not isinstance(tool, Tool):
             raise TypeError(
-                "Must provide a `Tool` object or a callable function."
+                "Must provide a `Tool` object, a callable function, or an MCP config dict."
             )
         self.registry[tool.function] = tool
 
@@ -245,7 +252,258 @@ class ActionManager(Manager):
             ]
         raise TypeError(f"Unsupported type {type(tool)}")
 
+    async def register_mcp_server(
+        self,
+        server_config: dict[str, Any],
+        tool_names: list[str] | None = None,
+        request_options: dict[str, type] | None = None,
+        update: bool = False,
+    ) -> list[str]:
+        """
+        Register tools from an MCP server with automatic discovery.
+
+        Args:
+            server_config: MCP server configuration (command, args, etc.)
+                          Can be {"server": "name"} to reference loaded config
+                          or full config dict with command/args
+            tool_names: Optional list of specific tool names to register.
+                       If None, will discover and register all available tools.
+            request_options: Optional dict mapping tool names to Pydantic model classes
+                            for request validation. E.g., {"exa_search": ExaSearchRequest}
+            update: If True, allow updating existing tools.
+
+        Returns:
+            List of registered tool names
+
+        Example:
+            # Auto-discover with Pydantic validation
+            from lionagi.service.third_party.exa_models import ExaSearchRequest
+            tools = await manager.register_mcp_server(
+                {"server": "search"},
+                request_options={"exa_search": ExaSearchRequest}
+            )
+
+            # Register specific tools only
+            tools = await manager.register_mcp_server(
+                {"command": "python", "args": ["-m", "server"]},
+                tool_names=["search", "fetch"]
+            )
+        """
+        registered_tools = []
+
+        # Extract server name for qualified naming
+        server_name = None
+        if isinstance(server_config, dict) and "server" in server_config:
+            server_name = server_config["server"]
+
+        if tool_names:
+            # Register specific tools with qualified names
+            for tool_name in tool_names:
+                # Use qualified name to avoid collisions
+                qualified_name = (
+                    f"{server_name}_{tool_name}" if server_name else tool_name
+                )
+
+                # Store original tool name in config for MCP calls
+                config_with_metadata = dict(server_config)
+                config_with_metadata["_original_tool_name"] = tool_name
+
+                mcp_config = {qualified_name: config_with_metadata}
+
+                # Get request_options for this tool if provided
+                tool_request_options = None
+                if request_options and tool_name in request_options:
+                    tool_request_options = request_options[tool_name]
+
+                # Create tool with request_options for Pydantic validation
+                tool = Tool(
+                    mcp_config=mcp_config, request_options=tool_request_options
+                )
+                self.register_tool(tool, update=update)
+                registered_tools.append(qualified_name)
+        else:
+            # Auto-discover tools from the server
+            from lionagi.service.connections.mcp.wrapper import (
+                MCPConnectionPool,
+            )
+
+            # Get client and discover tools
+            client = await MCPConnectionPool.get_client(server_config)
+            tools = await client.list_tools()
+
+            # Register each discovered tool with qualified name
+            for tool in tools:
+                # Use qualified name to avoid collisions: server_toolname
+                qualified_name = (
+                    f"{server_name}_{tool.name}" if server_name else tool.name
+                )
+
+                # Store original tool name in config for MCP calls
+                config_with_metadata = dict(server_config)
+                config_with_metadata["_original_tool_name"] = tool.name
+
+                mcp_config = {qualified_name: config_with_metadata}
+
+                # Get request_options for this tool if provided
+                tool_request_options = None
+                if request_options and tool.name in request_options:
+                    tool_request_options = request_options[tool.name]
+
+                try:
+                    # Create tool with request_options for Pydantic validation
+                    tool_obj = Tool(
+                        mcp_config=mcp_config,
+                        request_options=tool_request_options,
+                    )
+                    self.register_tool(tool_obj, update=update)
+                    registered_tools.append(qualified_name)
+                except Exception as e:
+                    print(
+                        f"Warning: Failed to register tool {qualified_name}: {e}"
+                    )
+
+        return registered_tools
+
+    async def load_mcp_config(
+        self,
+        config_path: str,
+        server_names: list[str] | None = None,
+        update: bool = False,
+    ) -> dict[str, list[str]]:
+        """
+        Load MCP configurations from a .mcp.json file with auto-discovery.
+
+        Args:
+            config_path: Path to .mcp.json configuration file
+            server_names: Optional list of server names to load.
+                         If None, loads all servers.
+            update: If True, allow updating existing tools.
+
+        Returns:
+            Dict mapping server names to lists of registered tool names
+
+        Example:
+            # Load all servers and auto-discover their tools
+            tools = await manager.load_mcp_config("/path/to/.mcp.json")
+
+            # Load specific servers only
+            tools = await manager.load_mcp_config(
+                "/path/to/.mcp.json",
+                server_names=["search", "memory"]
+            )
+        """
+        from lionagi.service.connections.mcp.wrapper import MCPConnectionPool
+
+        # Load the config file into the connection pool
+        MCPConnectionPool.load_config(config_path)
+
+        # Get server list to process
+        if server_names is None:
+            # Get all server names from loaded config
+            # The config has already been validated by load_config
+            server_names = list(MCPConnectionPool._configs.keys())
+
+        # Register tools from each server
+        all_tools = {}
+        for server_name in server_names:
+            try:
+                # Register using server reference
+                tools = await self.register_mcp_server(
+                    {"server": server_name}, update=update
+                )
+                all_tools[server_name] = tools
+                print(
+                    f"✅ Registered {len(tools)} tools from server '{server_name}'"
+                )
+            except Exception as e:
+                print(f"⚠️  Failed to register server '{server_name}': {e}")
+                all_tools[server_name] = []
+
+        return all_tools
+
+
+async def load_mcp_tools(
+    config_path: str | None = None,
+    server_names: list[str] | None = None,
+    request_options_map: dict[str, dict[str, type]] | None = None,
+    update: bool = False,
+) -> list[Tool]:
+    """
+    Standalone helper function to load MCP tools from servers.
+    Creates an ActionManager internally and returns tools ready for use.
+
+    Args:
+        config_path: Path to .mcp.json file. If None, assumes config already loaded.
+        server_names: Optional list of server names to load.
+                     If None, loads all servers from config.
+        request_options_map: Optional dict mapping server names to tool request options.
+                             E.g., {"search": {"exa_search": ExaSearchRequest}}
+        update: If True, allow updating existing tools.
+
+    Returns:
+        List of Tool objects ready to use with Branch
+
+    Example:
+        # Simple one-liner to get MCP tools
+        from lionagi.protocols.action.manager import load_mcp_tools
+        from lionagi.service.third_party.exa_models import ExaSearchRequest
+        from lionagi.service.third_party.pplx_models import PerplexityChatRequest
+
+        # Load with Pydantic validation
+        tools = await load_mcp_tools(
+            "/path/to/.mcp.json",
+            ["search"],
+            request_options_map={
+                "search": {
+                    "exa_search": ExaSearchRequest,
+                    "perplexity_search": PerplexityChatRequest
+                }
+            }
+        )
+        branch = Branch(tools=tools)
+    """
+    from lionagi.service.connections.mcp.wrapper import MCPConnectionPool
+
+    # Create a temporary ActionManager for tool management
+    manager = ActionManager()
+
+    # Load config if provided
+    if config_path:
+        MCPConnectionPool.load_config(config_path)
+
+    # If no server names specified, discover from config
+    if server_names is None and config_path:
+        # Get all server names from loaded config
+        server_names = list(MCPConnectionPool._configs.keys())
+
+    if server_names is None:
+        raise ValueError(
+            "Either provide server_names or config_path to discover servers"
+        )
+
+    # Register all servers
+    for server_name in server_names:
+        try:
+            # Get request_options for this server if provided
+            request_options = None
+            if request_options_map and server_name in request_options_map:
+                request_options = request_options_map[server_name]
+
+            tools_registered = await manager.register_mcp_server(
+                {"server": server_name},
+                request_options=request_options,
+                update=update,
+            )
+            print(
+                f"✅ Loaded {len(tools_registered)} tools from {server_name}"
+            )
+        except Exception as e:
+            print(f"⚠️  Failed to load server '{server_name}': {e}")
+
+    # Return all registered tools as a list
+    return list(manager.registry.values())
+
 
-__all__ = ["ActionManager"]
+__all__ = ["ActionManager", "load_mcp_tools"]
 
 # File: lionagi/protocols/action/manager.py

lionagi/protocols/action/tool.py

@@ -7,11 +7,9 @@ import inspect
 from collections.abc import Callable
 from typing import Any, TypeAlias
 
-from pydantic import Field, field_validator, model_validator
+from pydantic import Field, model_validator
 from typing_extensions import Self
 
-from lionagi.libs.schema.function_to_schema import function_to_schema
-from lionagi.libs.validate.common_field_validators import validate_callable
 from lionagi.protocols.generic.element import Element
 
 __all__ = (
@@ -39,6 +37,9 @@ class Tool(Element):
         exclude=True,
     )
 
+    mcp_config: dict[str, dict[str, Any]] | None = None
+    """{tool_name: mcp_config dict}"""
+
     tool_schema: dict[str, Any] | None = Field(
         default=None,
         description="Schema describing the function's parameters and structure",
@@ -78,15 +79,46 @@ class Tool(Element):
         description="Whether to enforce strict validation of function parameters",
     )
 
-    @field_validator("func_callable", mode="before")
-    def _validate_func_callable(cls, value: Any) -> Callable[..., Any]:
-        return validate_callable(
-            cls, value, undefind_able=False, check_name=True
-        )
+    @model_validator(mode="before")
+    def _validate_callable_config(cls, data):
+        mcp_config = data.get("mcp_config")
+        func_callable = data.get("func_callable")
+
+        if mcp_config is not None:
+            if func_callable is not None:
+                raise ValueError(
+                    "`mcp_config` and `func_callable` cannot both be set."
+                )
+            if not isinstance(mcp_config, dict):
+                raise ValueError("`mcp_config` must be a dictionary.")
+            if len(mcp_config) != 1:
+                raise ValueError(
+                    "`mcp_config` must contain exactly one entry."
+                )
+            tool_name, config = next(iter(mcp_config.items()))
+
+            from lionagi.service.connections.mcp.wrapper import create_mcp_tool
+
+            func_callable = create_mcp_tool(config, tool_name)
+        else:
+            from lionagi.libs.validate.common_field_validators import (
+                validate_callable,
+            )
+
+            validate_callable(
+                cls, func_callable, undefind_able=False, check_name=True
+            )
+
+        data["func_callable"] = func_callable
+        return data
 
     @model_validator(mode="after")
     def _validate_tool_schema(self) -> Self:
         if self.tool_schema is None:
+            from lionagi.libs.schema.function_to_schema import (
+                function_to_schema,
+            )
+
             self.tool_schema = function_to_schema(
                 self.func_callable, request_options=self.request_options
             )
@@ -117,10 +149,9 @@ class Tool(Element):
                 ).parameters.items()
                 if v.default == inspect.Parameter.empty
             }
-            if "kwargs" in a:
-                a.remove("kwargs")
-            if "args" in a:
-                a.remove("args")
+            for i in ("kw", "kwargs", "args"):
+                if i in a:
+                    a.remove(i)
             return a
         except Exception:
             return set()
@@ -142,8 +173,8 @@ class Tool(Element):
         return dict_
 
 
-FuncTool: TypeAlias = Tool | Callable[..., Any]
-"""Represents either a `Tool` instance or a raw callable function."""
+FuncTool: TypeAlias = Tool | Callable[..., Any] | dict
+"""Represents either a `Tool` instance, a raw callable function or mcp config."""
 
 FuncToolRef: TypeAlias = FuncTool | str
 """
@@ -157,19 +188,4 @@ Used for specifying one or more tool references, or a boolean
 indicating 'all' or 'none'.
 """
 
-
-def func_to_tool(func: Callable[..., Any], **kwargs) -> Tool:
-    """
-    Convenience function that wraps a raw function in a `Tool`.
-
-    Args:
-        func (Callable[..., Any]): The function to wrap.
-        **kwargs: Additional arguments passed to the `Tool` constructor.
-
-    Returns:
-        Tool: A new Tool instance wrapping `func`.
-    """
-    return Tool(func_callable=func, **kwargs)
-
-
 # File: lionagi/protocols/action/tool.py

lionagi/protocols/generic/pile.py

@@ -1048,7 +1048,12 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
 
     def to_df(self, columns: list[str] | None = None, **kw: Any):
         """Convert to DataFrame."""
-        from pydapter.extras.pandas_ import DataFrameAdapter
+        try:
+            from pydapter.extras.pandas_ import DataFrameAdapter
+        except ImportError as e:
+            raise ImportError(
+                "pandas is required for to_df(). Please install it via `pip install pandas`."
+            ) from e
 
         df = DataFrameAdapter.to_obj(
             list(self.collections.values()), adapt_meth="to_dict", **kw

lionagi/protocols/messages/assistant_response.py

@@ -198,5 +198,11 @@ class AssistantResponse(RoledMessage):
             sender=sender, recipient=recipient, template=template, **kwargs
         )
 
+    def as_context(self) -> dict:
+        return f"""
+            Response: {self.response or "Not available"}
+            Summary: {self.model_response.get("summary") or "Not available"}
+        """.strip()
+
 
 # File: lionagi/protocols/messages/assistant_response.py

lionagi/service/connections/mcp/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/service/connections/mcp/wrapper.py

@@ -0,0 +1,259 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+try:
+    from fastmcp import Client as FastMCPClient
+
+    FASTMCP_AVAILABLE = True
+except ImportError:
+    FASTMCP_AVAILABLE = False
+    FastMCPClient = None
+
+# Suppress MCP server logging by default
+logging.getLogger("mcp").setLevel(logging.WARNING)
+logging.getLogger("fastmcp").setLevel(logging.WARNING)
+logging.getLogger("mcp.server").setLevel(logging.WARNING)
+logging.getLogger("mcp.server.lowlevel").setLevel(logging.WARNING)
+logging.getLogger("mcp.server.lowlevel.server").setLevel(logging.WARNING)
+
+
+class MCPConnectionPool:
+    """Simple connection pool for MCP clients.
+
+    Security Model:
+    This class trusts user-provided MCP server configurations, similar to how
+    development tools trust configured language servers or extensions. Users are
+    responsible for vetting the MCP servers they choose to run.
+
+    For enhanced security in production:
+    - Run MCP servers in sandboxed environments (containers, VMs)
+    - Use process isolation and resource limits
+    - Monitor server behavior and resource usage
+    - Validate server outputs before use
+    """
+
+    _clients: dict[str, Any] = {}
+    _configs: dict[str, dict] = {}
+    _lock = asyncio.Lock()
+
+    async def __aenter__(self):
+        """Context manager entry."""
+        return self
+
+    async def __aexit__(self, *_):
+        """Context manager exit - cleanup connections."""
+        await self.cleanup()
+
+    @classmethod
+    def load_config(cls, path: str = ".mcp.json") -> None:
+        """Load MCP server configurations from file.
+
+        Args:
+            path: Path to .mcp.json configuration file
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            json.JSONDecodeError: If config file has invalid JSON
+            ValueError: If config structure is invalid
+        """
+        config_path = Path(path)
+        if not config_path.exists():
+            raise FileNotFoundError(f"MCP config file not found: {path}")
+
+        try:
+            with open(config_path) as f:
+                data = json.load(f)
+        except json.JSONDecodeError as e:
+            raise json.JSONDecodeError(
+                f"Invalid JSON in MCP config file: {e.msg}", e.doc, e.pos
+            )
+
+        if not isinstance(data, dict):
+            raise ValueError("MCP config must be a JSON object")
+
+        servers = data.get("mcpServers", {})
+        if not isinstance(servers, dict):
+            raise ValueError("mcpServers must be a dictionary")
+
+        cls._configs.update(servers)
+
+    @classmethod
+    async def get_client(cls, server_config: dict[str, Any]) -> Any:
+        """Get or create a pooled MCP client."""
+        if not FASTMCP_AVAILABLE:
+            raise ImportError(
+                "FastMCP not installed. Run: pip install fastmcp"
+            )
+
+        # Generate unique key for this config
+        if "server" in server_config:
+            # Server reference from .mcp.json
+            server_name = server_config["server"]
+            if server_name not in cls._configs:
+                # Try loading config
+                cls.load_config()
+                if server_name not in cls._configs:
+                    raise ValueError(f"Unknown MCP server: {server_name}")
+
+            config = cls._configs[server_name]
+            cache_key = f"server:{server_name}"
+        else:
+            # Inline config - use command as key
+            config = server_config
+            cache_key = f"inline:{config.get('command')}:{id(config)}"
+
+        # Check if client exists and is connected
+        async with cls._lock:
+            if cache_key in cls._clients:
+                client = cls._clients[cache_key]
+                # Simple connectivity check
+                if hasattr(client, "is_connected") and client.is_connected():
+                    return client
+                else:
+                    # Remove stale client
+                    del cls._clients[cache_key]
+
+            # Create new client
+            client = await cls._create_client(config)
+            cls._clients[cache_key] = client
+            return client
+
+    @classmethod
+    async def _create_client(cls, config: dict[str, Any]) -> Any:
+        """Create a new MCP client from config.
+
+        Security Note:
+        MCP servers are explicitly configured by users via .mcp.json files or API calls.
+        The security model trusts user-provided configurations, similar to how IDEs trust
+        configured language servers. For additional security, run MCP servers in sandboxed
+        environments (containers, VMs) rather than restricting commands at the library level.
+
+        Args:
+            config: Server configuration with 'url' or 'command' + optional 'args' and 'env'
+
+        Raises:
+            ValueError: If config format is invalid
+        """
+        # Validate config structure
+        if not isinstance(config, dict):
+            raise ValueError("Config must be a dictionary")
+
+        if not any(k in config for k in ["url", "command"]):
+            raise ValueError("Config must have either 'url' or 'command' key")
+
+        # Handle different config formats
+        if "url" in config:
+            # Direct URL connection
+            client = FastMCPClient(config["url"])
+        elif "command" in config:
+            # Command-based connection
+            # Validate args if provided
+            args = config.get("args", [])
+            if not isinstance(args, list):
+                raise ValueError("Config 'args' must be a list")
+
+            # Merge environment variables - user config takes precedence
+            env = os.environ.copy()
+            env.update(config.get("env", {}))
+
+            # Suppress server logging unless debug mode is enabled
+            if not (
+                config.get("debug", False)
+                or os.environ.get("MCP_DEBUG", "").lower() == "true"
+            ):
+                # Common environment variables to suppress logging
+                env.setdefault("LOG_LEVEL", "ERROR")
+                env.setdefault("PYTHONWARNINGS", "ignore")
+                env.setdefault("KHIVEMCP_LOG_LEVEL", "ERROR")
+                # Suppress FastMCP server logs
+                env.setdefault("FASTMCP_QUIET", "true")
+                env.setdefault("MCP_QUIET", "true")
+
+            # Create client with command
+            from fastmcp.client.transports import StdioTransport
+
+            transport = StdioTransport(
+                command=config["command"],
+                args=args,
+                env=env,
+            )
+            client = FastMCPClient(transport)
+        else:
+            raise ValueError("Config must have 'url' or 'command'")
+
+        # Initialize connection
+        await client.__aenter__()
+        return client
+
+    @classmethod
+    async def cleanup(cls):
+        """Clean up all pooled connections."""
+        async with cls._lock:
+            for cache_key, client in cls._clients.items():
+                try:
+                    await client.__aexit__(None, None, None)
+                except Exception as e:
+                    # Log cleanup errors for debugging while continuing cleanup
+                    logging.debug(
+                        f"Error cleaning up MCP client {cache_key}: {e}"
+                    )
+            cls._clients.clear()
+
+
+def create_mcp_tool(mcp_config: dict[str, Any], tool_name: str) -> Any:
+    """Create a callable that wraps MCP tool execution.
+
+    Args:
+        mcp_config: MCP server configuration (server reference or inline)
+        tool_name: Name of the tool (can be qualified like "server_toolname")
+
+    Returns:
+        Async callable that executes the MCP tool
+    """
+
+    async def mcp_callable(**kwargs):
+        """Execute MCP tool with connection pooling."""
+        # Extract the original tool name if it was stored in metadata
+        actual_tool_name = mcp_config.get("_original_tool_name", tool_name)
+
+        # Remove metadata before getting client
+        config_for_client = {
+            k: v for k, v in mcp_config.items() if not k.startswith("_")
+        }
+
+        client = await MCPConnectionPool.get_client(config_for_client)
+
+        # Call the tool with the original name
+        result = await client.call_tool(actual_tool_name, kwargs)
+
+        # Handle different result types
+        if hasattr(result, "content"):
+            # CallToolResult object - extract content
+            content = result.content
+            if isinstance(content, list) and len(content) == 1:
+                item = content[0]
+                if hasattr(item, "text"):
+                    return item.text
+                elif isinstance(item, dict) and item.get("type") == "text":
+                    return item.get("text", "")
+            return content
+        elif isinstance(result, list) and len(result) == 1:
+            item = result[0]
+            if isinstance(item, dict) and item.get("type") == "text":
+                return item.get("text", "")
+
+        return result
+
+    # Set function metadata for Tool introspection
+    mcp_callable.__name__ = tool_name
+    mcp_callable.__doc__ = f"MCP tool: {tool_name}"
+
+    return mcp_callable

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.17.2"
+__version__ = "0.17.4"

{lionagi-0.17.2.dist-info → lionagi-0.17.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.17.2
+Version: 0.17.4
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -374,6 +374,33 @@ print(result)
 The LLM can now open the PDF, read in slices, fetch references, and produce a
 final structured summary.
 
+### MCP (Model Context Protocol) Integration
+
+LionAGI supports Anthropic's Model Context Protocol for seamless tool integration:
+
+```
+pip install "lionagi[mcp]"
+```
+
+```python
+from lionagi import load_mcp_tools
+
+# Load tools from any MCP server
+tools = await load_mcp_tools(".mcp.json", ["search", "memory"])
+
+# Use with ReAct reasoning
+branch = Branch(chat_model=gpt4o, tools=tools)
+result = await branch.ReAct(
+    instruct={"instruction": "Research recent AI developments"},
+    tools=["search_exa_search"],
+    max_extensions=3
+)
+```
+
+- **Dynamic Discovery**: Auto-discover and register tools from MCP servers
+- **Type Safety**: Full Pydantic validation for tool interactions
+- **Connection Pooling**: Efficient resource management with automatic reuse
+
 ### Observability & Debugging
 
 - Inspect messages:

{lionagi-0.17.2.dist-info → lionagi-0.17.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lionagi/__init__.py,sha256=KDyBBo2Ahdk44akAbUG7ZZATdZhVvl8WHEr6HXMC6vA,1196
+lionagi/__init__.py,sha256=Kh_2iWIL1mvvtMAETJ5cRxIxRkiAERYAJmK1IOgNtvQ,1335
 lionagi/_class_registry.py,sha256=pfUO1DjFZIqr3OwnNMkFqL_fiEBrrf8-swkGmP_KDLE,3112
 lionagi/_errors.py,sha256=ia_VWhPSyr5FIJLSdPpl04SrNOLI2skN40VC8ePmzeQ,3748
 lionagi/_types.py,sha256=COWRrmstmABGKKn-h_cKiAREGsMp_Ik49OdR4lSS3P8,1263
@@ -6,7 +6,7 @@ lionagi/config.py,sha256=D13nnjpgJKz_LlQrzaKKVefm4hqesz_dP9ROjWmGuLE,3811
 lionagi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/settings.py,sha256=HDuKCEJCpc4HudKodBnhoQUGuTGhRHdlIFhbtf3VBtY,1633
 lionagi/utils.py,sha256=pfAibR84sx-aPxGNPrdlHqUAf2OXoCBGRCMseMrzhi4,18046
-lionagi/version.py,sha256=I5u6uLh7NsbyGkKLvVteW175Afe6HJt5UsjBZ28EGks,23
+lionagi/version.py,sha256=LisYi6U4jD61j06adgCNdZJfR0RhF_Im0hPrka6lSjc,23
 lionagi/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/adapters/_utils.py,sha256=sniMG1LDDkwJNzUF2K32jv7rA6Y1QcohgyNclYsptzI,453
 lionagi/adapters/async_postgres_adapter.py,sha256=2XlxYNPow78dFHIQs8W1oJ2zkVD5Udn3aynMBF9Nf3k,3498
@@ -109,8 +109,8 @@ lionagi/protocols/ids.py,sha256=RM40pP_4waMJcfCGmEK_PfS8-k_DuDbC1fG-2Peuf6s,2472
 lionagi/protocols/types.py,sha256=6GJ5ZgDyWl8tckNLXB0z8jbtkordWpgm5r4ht31KVRc,2431
 lionagi/protocols/action/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/action/function_calling.py,sha256=jFy6Ruh3QWkERtBHXqPWVwrOH5aDitEo8oJHZgW5xnI,5066
-lionagi/protocols/action/manager.py,sha256=XmdQIaVgSpmFBFW9kbW_rdwdQmlBteP4VRanxh_f918,8549
-lionagi/protocols/action/tool.py,sha256=h2FAY1b8y3LXrvAtfFhvdv1nu8cwz2knUeRCi2G9k1E,5243
+lionagi/protocols/action/manager.py,sha256=akq3HuLUuTRkm7ENmn8oycNH-4ksfekXOwOJky5OBrE,18835
+lionagi/protocols/action/tool.py,sha256=_o7rLokD3poupqst6YoQqEC6RvePDueySoVrGK2S538,5850
 lionagi/protocols/forms/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/forms/base.py,sha256=1J8UU2LXm1Lax5McJos0xjZTzMVLYQWd_hwtxI2wSuM,2838
 lionagi/protocols/forms/flow.py,sha256=t9Ycvmb-stj0rCyvXXwd7WBcDtuCCTEKYst2aqFDVag,2702
@@ -120,7 +120,7 @@ lionagi/protocols/generic/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGv
 lionagi/protocols/generic/element.py,sha256=yD4SWNOGZsLTgxtz6TKtJfqkUvDmUH9wIH3Liw6QmmA,15839
 lionagi/protocols/generic/event.py,sha256=n5EraAJ5bPiwegTdkxsILs7-vFJwmnXhB2om4xMQnK0,6529
 lionagi/protocols/generic/log.py,sha256=AnPr2RweSZcJdxOK0KGb1eyvAPZmME3hEm9HraUoftQ,8212
-lionagi/protocols/generic/pile.py,sha256=AHxj1q5apabATmdgGXlAhkcqIug9r_75wmufdq9XLt4,36894
+lionagi/protocols/generic/pile.py,sha256=rB13BzHhGHcJlijXmKNUdTS1WzcBzpMM1wycPv9ogk4,37090
 lionagi/protocols/generic/processor.py,sha256=uiNIldAYPEujuboLFyrIJADMlhRghy3H86hYintj5D4,11705
 lionagi/protocols/generic/progression.py,sha256=HCV_EnQCFvjg6D7eF4ygGrZNQPEOtu75zvW1sJbAVrM,15190
 lionagi/protocols/graph/__init__.py,sha256=UPu3OmUpjSgX2aBuBJUdG2fppGlfqAH96hU0qIMBMp0,253
@@ -136,7 +136,7 @@ lionagi/protocols/mail/package.py,sha256=qcKRWP5Lk3wTK_rJhRsXFQhWz0pb2Clcs7vJcMw
 lionagi/protocols/messages/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/protocols/messages/action_request.py,sha256=-tG9ViTSiZ2beM0onE6C552H5oth-sHLHP6KsBV8OMk,6868
 lionagi/protocols/messages/action_response.py,sha256=SM3_vA9QPXz3Gc9uPhXm3zOXYheHZZGtl67Yff48Vu8,5272
-lionagi/protocols/messages/assistant_response.py,sha256=jrzRPVHHDnPw86Xp0IHnPy0tOZdsk7rBwhG5xnBXAjs,6912
+lionagi/protocols/messages/assistant_response.py,sha256=e7seqUyYCXwInQrHWhNwIf9y40hgP_mH_-9-juItflw,7121
 lionagi/protocols/messages/base.py,sha256=Ng1Q8yIIIFauUv53LnwDeyOrM-cSCfsHM1GwkxChf2o,2317
 lionagi/protocols/messages/instruction.py,sha256=Qpme1oSc406V3-F2iOyqC8TVT2GWVduZaoDfdGdBnDI,21127
 lionagi/protocols/messages/manager.py,sha256=ABDiN-QULbfbSrHVlPe3kqBxr7e7sYoT49wHQMLiT6c,16897
@@ -165,6 +165,8 @@ lionagi/service/connections/endpoint.py,sha256=0r4-8NPyAvLNey09BBsUr5KGJCXchBmVZ
 lionagi/service/connections/endpoint_config.py,sha256=6sA06uCzriT6p0kFxhDCFH8N6V6MVp8ytlOw5ctBhDI,5169
 lionagi/service/connections/header_factory.py,sha256=IYeTQQk7r8FXcdhmW7orCxHjNO-Nb1EOXhgNK7CAp-I,1821
 lionagi/service/connections/match_endpoint.py,sha256=QlOw9CbR1peExP-b-XlkRpqqGIksfNefI2EZCw9P7_E,2575
+lionagi/service/connections/mcp/__init__.py,sha256=3lzOakDoBWmMaNnT2g-YwktPKa_Wme4lnPRSmOQfayY,105
+lionagi/service/connections/mcp/wrapper.py,sha256=fqH2FtZa0mAehXTAfFZrxUvlj-WUSZSUWlcZb1XjkUc,9322
 lionagi/service/connections/providers/__init__.py,sha256=3lzOakDoBWmMaNnT2g-YwktPKa_Wme4lnPRSmOQfayY,105
 lionagi/service/connections/providers/anthropic_.py,sha256=vok8mIyFiuV3K83tOjdYfruA6cv1h_57ML6RtpuW-bU,3157
 lionagi/service/connections/providers/claude_code_cli.py,sha256=kqEOnCUOOh2O_3NGi6W7r-gdLsbW-Jcp11tm30VEv4Q,4455
@@ -195,7 +197,7 @@ lionagi/tools/base.py,sha256=hEGnE4MD0CM4UqnF0xsDRKB0aM-pyrTFHl8utHhyJLU,1897
 lionagi/tools/types.py,sha256=XtJLY0m-Yi_ZLWhm0KycayvqMCZd--HxfQ0x9vFUYDE,230
 lionagi/tools/file/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/file/reader.py,sha256=2YKgU3VKo76zfL_buDAUQJoPLC56f6WJ4_mdJjlMDIM,9509
-lionagi-0.17.2.dist-info/METADATA,sha256=AXGNj_mj3gEEDpn7gAtSO5t7W1dkhW_8LVbfSxfbP7A,22674
-lionagi-0.17.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.17.2.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.17.2.dist-info/RECORD,,
+lionagi-0.17.4.dist-info/METADATA,sha256=mVBP2MOOqq5vysEk8mmDMc76OpXbNuIFoqSYjBVyhDI,23432
+lionagi-0.17.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.17.4.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.17.4.dist-info/RECORD,,