aip-agents-binary 0.4.8__cp312-cp312-win_amd64.whl → 0.5.4__cp312-cp312-win_amd64.whl

aip_agents/examples/pii_demo_multi_agent_server.pyi

@@ -0,0 +1,40 @@
+from _typeshed import Incomplete
+from aip_agents.agent import LangGraphAgent as LangGraphAgent
+from aip_agents.examples.tools.pii_demo_tools import get_customer_info as get_customer_info, get_employee_data as get_employee_data, get_user_profile as get_user_profile
+from aip_agents.utils.logger import LoggerManager as LoggerManager
+from langchain_openai import ChatOpenAI
+
+logger: Incomplete
+SERVER_AGENT_NAME: str
+
+def create_specialist_agents(llm: ChatOpenAI) -> tuple[LangGraphAgent, LangGraphAgent, LangGraphAgent]:
+    """Create Level 2 specialist agents with PII-returning tools.
+
+    Args:
+        llm: The language model to use for the specialist agents.
+
+    Returns:
+        Tuple of (customer_service_agent, hr_agent, user_support_agent).
+    """
+def create_coordinator_agent(llm: ChatOpenAI, specialist_agents: tuple[LangGraphAgent, LangGraphAgent, LangGraphAgent]) -> LangGraphAgent:
+    """Create Level 1 coordinator agent that orchestrates specialist agents.
+
+    Args:
+        llm: The language model to use for the coordinator agent.
+        specialist_agents: Tuple of specialist agents.
+
+    Returns:
+        The configured coordinator agent.
+    """
+def main(host: str, port: int):
+    """Runs the Multi-Agent PII Demo A2A server.
+
+    This server demonstrates PII handling across a multi-agent hierarchy:
+    - PII anonymization in tool outputs
+    - PII propagation from child agents to parent
+    - Multi-agent delegation with PII mapping merge
+
+    Args:
+        host: Host to bind the server to.
+        port: Port to bind the server to.
+    """

aip_agents/examples/todolist_planning_a2a_langchain_client.pyi

@@ -0,0 +1,5 @@
+from aip_agents.agent import LangChainAgent as LangChainAgent
+from aip_agents.schema.agent import A2AClientConfig as A2AClientConfig
+
+async def main() -> None:
+    """Connect to the planning A2A server and stream a planning query."""

aip_agents/examples/todolist_planning_a2a_langgraph_server.pyi

@@ -0,0 +1,19 @@
+from _typeshed import Incomplete
+from aip_agents.agent import LangGraphReactAgent as LangGraphReactAgent
+from aip_agents.examples.tools.serper_tool import MockGoogleSerperTool as MockGoogleSerperTool
+from aip_agents.examples.tools.stock_tools import get_stock_price as get_stock_price
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+SERVER_AGENT_NAME: str
+
+def main(host: str, port: int) -> None:
+    """Run an A2A server with a planning-enabled LangGraphReactAgent.
+
+    The agent has TodoListMiddleware attached via planning=True and will
+    expose the write_todos_tool over A2A with token streaming enabled.
+
+    Args:
+        host: The host to bind the server to.
+        port: The port to bind the server to.
+    """

aip_agents/examples/tools/__init__.pyi

@@ -1,7 +1,9 @@
 from aip_agents.examples.tools.adk_weather_tool import get_weather as weather_tool_adk
 from aip_agents.examples.tools.langchain_weather_tool import weather_tool as weather_tool_langchain
 from aip_agents.examples.tools.langgraph_streaming_tool import LangGraphStreamingTool as langgraph_streaming_tool
+from aip_agents.examples.tools.mock_retrieval_tool import MockRetrievalTool as mock_retrieval_tool
+from aip_agents.examples.tools.random_chart_tool import RandomChartTool as random_chart_tool
 from aip_agents.examples.tools.serper_tool import MockGoogleSerperTool as google_serper_tool
 from aip_agents.examples.tools.time_tool import TimeTool as time_tool
 
-__all__ = ['weather_tool_langchain', 'weather_tool_adk', 'time_tool', 'google_serper_tool', 'langgraph_streaming_tool']
+__all__ = ['weather_tool_langchain', 'weather_tool_adk', 'time_tool', 'google_serper_tool', 'langgraph_streaming_tool', 'mock_retrieval_tool', 'random_chart_tool']

aip_agents/examples/tools/adk_weather_tool.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
+from aip_agents.utils.logger import get_logger as get_logger
 
 logger: Incomplete
 WEATHER_DATA: Incomplete

aip_agents/examples/tools/data_visualization_tool.pyi

@@ -4,6 +4,8 @@ from langchain_core.tools import BaseTool
 from pydantic import BaseModel
 from typing import Any
 
+PIL_AVAILABLE: bool
+
 class ChartInput(BaseModel):
     """Input schema for chart generation."""
     data_source: Any

aip_agents/examples/tools/image_artifact_tool.pyi

@@ -3,6 +3,8 @@ from aip_agents.utils.artifact_helpers import create_artifact_response as create
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
 
+PIL_AVAILABLE: bool
+
 class ImageArtifactInput(BaseModel):
     """Input schema for image artifact tool."""
     width: int

aip_agents/examples/tools/langchain_arithmetic_tools.pyi

@@ -7,4 +7,11 @@ def add_numbers(a: int, b: int) -> str:
     This is a self-contained LangChain tool.
     For example:
     add_numbers(a=5, b=3)
+
+    Args:
+        a (int): First number to add.
+        b (int): Second number to add.
+
+    Returns:
+        str: Sum of the two numbers as a string.
     """

aip_agents/examples/tools/langchain_currency_exchange_tool.pyi

@@ -1,4 +1,3 @@
-from langchain_core.runnables import RunnableConfig as RunnableConfig
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
 

aip_agents/examples/tools/langchain_graph_artifact_tool.pyi

@@ -3,6 +3,8 @@ from aip_agents.utils.artifact_helpers import create_artifact_command as create_
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
 
+PIL_AVAILABLE: bool
+
 class GraphCommandInput(BaseModel):
     """Input schema for a tiny bar/line chart artifact tool.
 

aip_agents/examples/tools/langchain_weather_tool.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
+from aip_agents.utils.logger import get_logger as get_logger
 from pydantic import BaseModel
 
 logger: Incomplete

aip_agents/examples/tools/langgraph_streaming_tool.pyi

@@ -1,7 +1,7 @@
 from aip_agents.agent.langgraph_react_agent import LangGraphReactAgent as LangGraphReactAgent
 from aip_agents.examples.tools.langchain_weather_tool import weather_tool as weather_tool
 from aip_agents.examples.tools.time_tool import TimeTool as TimeTool
-from langchain_core.runnables import RunnableConfig as RunnableConfig
+from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
 from typing import Any

aip_agents/examples/tools/mock_retrieval_tool.pyi

@@ -0,0 +1,13 @@
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+
+class MockRetrievalInput(BaseModel):
+    """Input schema for the MockRetrievalTool."""
+    query: str
+
+class MockRetrievalTool(BaseTool):
+    """Mock tool that returns hardcoded references for testing."""
+    name: str
+    description: str
+    args_schema: type[BaseModel]
+    save_output_history: bool

aip_agents/examples/tools/pii_demo_tools.pyi

@@ -0,0 +1,54 @@
+from _typeshed import Incomplete
+from aip_agents.utils.logger import LoggerManager as LoggerManager
+from pydantic import BaseModel
+
+logger: Incomplete
+
+class CustomerIdSchema(BaseModel):
+    """Schema for customer ID input."""
+    customer_id: str
+
+class EmployeeIdSchema(BaseModel):
+    """Schema for employee ID input."""
+    employee_id: str
+
+class UserIdSchema(BaseModel):
+    """Schema for user ID input."""
+    user_id: str
+
+def get_customer_info(customer_id: str) -> str:
+    """Gets customer information including email and phone number.
+
+    This tool demonstrates PII handling by returning sensitive customer data
+    that will be automatically anonymized by the PII handler.
+
+    Args:
+        customer_id: The ID of the customer to retrieve information for.
+
+    Returns:
+        A string containing customer information with PII.
+    """
+def get_employee_data(employee_id: str) -> str:
+    """Gets employee data including name, email, and salary information.
+
+    This tool demonstrates PII handling with employee-specific data that includes
+    sensitive information like salary and personal email addresses.
+
+    Args:
+        employee_id: The ID of the employee to retrieve data for.
+
+    Returns:
+        A string containing employee information with PII.
+    """
+def get_user_profile(user_id: str) -> str:
+    """Gets user profile information with personal details.
+
+    This tool demonstrates PII handling with user profile data that includes
+    personal information like email, phone, and date of birth.
+
+    Args:
+        user_id: The ID of the user to retrieve profile for.
+
+    Returns:
+        A string containing user profile information with PII.
+    """

aip_agents/examples/tools/random_chart_tool.pyi

@@ -0,0 +1,20 @@
+from aip_agents.a2a.types import MimeType as MimeType
+from aip_agents.utils.artifact_helpers import create_artifact_command as create_artifact_command
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+
+DEFAULT_RANDOM_CHART_TITLE: str
+PIL_AVAILABLE: bool
+
+class RandomChartInput(BaseModel):
+    """Input schema for random chart generation."""
+    title: str
+    num_bars: int
+    min_value: int
+    max_value: int
+
+class RandomChartTool(BaseTool):
+    """Generate random bar chart images without relying on upstream data."""
+    name: str
+    description: str
+    args_schema: type[BaseModel]

aip_agents/examples/tools/stock_tools.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
+from aip_agents.utils.logger import get_logger as get_logger
 from pydantic import BaseModel
 from typing import Any
 
@@ -10,7 +10,14 @@ class StockPriceInput(BaseModel):
     symbol: str
 
 def get_stock_price(symbol: str) -> dict[str, Any]:
-    """Get current stock price and performance data for a given symbol."""
+    """Get current stock price and performance data for a given symbol.
+
+    Args:
+        symbol (str): The stock symbol (e.g., AAPL, MSFT) to get the price for.
+
+    Returns:
+        dict[str, Any]: Dictionary containing stock price and performance data.
+    """
 
 class StockNewsInput(BaseModel):
     """Input for the stock news tool."""
@@ -18,4 +25,12 @@ class StockNewsInput(BaseModel):
     days: int
 
 def get_stock_news(symbol: str, days: int = 7) -> dict[str, Any]:
-    """Get recent news for a stock for a specified number of days."""
+    """Get recent news for a stock for a specified number of days.
+
+    Args:
+        symbol (str): The stock symbol (e.g., AAPL, MSFT) to get news for.
+        days (int, optional): Number of days of news to retrieve. Defaults to 7.
+
+    Returns:
+        dict[str, Any]: Dictionary containing stock news data.
+    """

aip_agents/mcp/client/__init__.pyi

@@ -1,4 +1,5 @@
-from .google_adk.client import GoogleADKMCPClient as GoogleADKMCPClient
-from .langchain.client import LangchainMCPClient as LangchainMCPClient
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.mcp.client.google_adk.client import GoogleADKMCPClient as GoogleADKMCPClient
+from aip_agents.mcp.client.langchain.client import LangchainMCPClient as LangchainMCPClient
 
-__all__ = ['GoogleADKMCPClient', 'LangchainMCPClient']
+__all__ = ['GoogleADKMCPClient', 'LangchainMCPClient', 'BaseMCPClient']

aip_agents/mcp/client/base_mcp_client.pyi

@@ -0,0 +1,148 @@
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from aip_agents.mcp.client.persistent_session import PersistentMCPSession as PersistentMCPSession
+from aip_agents.mcp.client.session_pool import MCPSessionPool as MCPSessionPool
+from aip_agents.utils.logger import get_logger as get_logger
+from gllm_tools.mcp.client.client import MCPClient
+from gllm_tools.mcp.client.config import MCPConfiguration as MCPConfiguration
+from mcp.types import CallToolResult, Tool as Tool
+from typing import Any
+
+logger: Incomplete
+
+class BaseMCPClient(MCPClient, ABC):
+    """Base MCP Client with persistent session management for aip-agents.
+
+    This class provides:
+    - Persistent session management across tool calls
+    - One-time tool registration and caching
+    - Automatic connection health monitoring and reconnection
+    - Centralized cleanup of all MCP resources
+    - Generic tool discovery from all configured MCP servers
+
+    Subclasses should implement SDK-specific tool conversion in _process_tool() method.
+    """
+    session_pool: Incomplete
+    def __init__(self, servers: dict[str, MCPConfiguration]) -> None:
+        """Initialize the base MCP client with session pool.
+
+        Args:
+            servers (dict[str, MCPConfiguration]): Dictionary of MCP server configurations by server name
+        """
+    async def initialize(self) -> None:
+        """Initialize all MCP sessions and cache tools once.
+
+        This method is idempotent and only performs initialization if not already done.
+        It establishes persistent connections to all configured MCP servers and caches
+        available tools for efficient access.
+
+        Raises:
+            Exception: If any session initialization fails
+        """
+    @abstractmethod
+    async def get_tools(self, server: str | None = None) -> list[Any]:
+        """Get framework-specific tools from MCP servers.
+
+        This method must be implemented by subclasses to provide framework-specific
+        tool conversion (e.g., StructuredTool for LangChain, FunctionTool for Google ADK).
+
+        Args:
+            server (str | None): Optional server name to filter tools from a specific server.
+                    If None, returns tools from all configured servers.
+
+        Returns:
+            list[Any]: List of framework-specific tool objects.
+        """
+    async def get_raw_mcp_tools(self, server: str | None = None) -> list[Tool]:
+        """Get raw MCP tools - for subclasses to perform framework-specific conversions.
+
+        This method provides access to the cached raw MCP Tool objects.
+        Subclasses use this to convert to framework-specific tools.
+
+        Args:
+            server (str | None): Optional server name to filter tools from a specific server.
+                    If None, returns tools from all configured servers.
+
+        Returns:
+            list[Tool]: List of raw MCP Tool objects. Empty list if not initialized or no tools available.
+        """
+    def get_tools_count(self, server: str | None = None) -> int:
+        """Get count of raw MCP tools without expensive copying.
+
+        This is an efficient way to get tool counts for logging/metrics
+        without the overhead of copying tool lists.
+
+        Args:
+            server (str | None): Optional server name to filter tools from a specific server.
+                    If None, returns count from all configured servers.
+
+        Returns:
+            int: Count of raw MCP tools available.
+        """
+    async def get_session(self, server_name: str) -> PersistentMCPSession:
+        """Get a persistent session for a specific server.
+
+        Args:
+            server_name (str): The name of the MCP server
+
+        Returns:
+            PersistentMCPSession: Persistent MCP session for the specified server
+
+        Raises:
+            KeyError: If the server is not configured or no active session exists
+        """
+    async def call_tool(self, server_name: str, tool_name: str, arguments: dict[str, Any]) -> CallToolResult:
+        """Execute a tool on a specific MCP server using persistent session.
+
+        Args:
+            server_name (str): The MCP server to execute the tool on
+            tool_name (str): The name of the tool to execute
+            arguments (dict[str, Any]): Arguments for the tool execution
+
+        Returns:
+            CallToolResult: The result of the tool execution
+
+        Raises:
+            KeyError: If the server doesn't exist
+            Exception: If tool execution fails
+        """
+    async def read_resource(self, server_name: str, resource_uri: str):
+        """Read an MCP resource from a specific server using persistent session.
+
+        Args:
+            server_name (str): The MCP server to read the resource from
+            resource_uri (str): The URI of the resource to read
+
+        Returns:
+            Any: The resource content
+
+        Raises:
+            KeyError: If the server doesn't exist
+            Exception: If resource reading fails
+        """
+    async def cleanup(self) -> None:
+        """Clean up all MCP resources and close sessions.
+
+        This method properly closes all persistent sessions and cleans up resources.
+        It can be called multiple times safely.
+        """
+    @property
+    def is_initialized(self) -> bool:
+        """Check if the client is fully initialized.
+
+        Returns:
+            bool: True if sessions are initialized and tools are cached, False otherwise
+        """
+    @property
+    def active_sessions(self) -> dict[str, PersistentMCPSession]:
+        """Get all active persistent sessions.
+
+        Returns:
+            dict[str, PersistentMCPSession]: Dictionary of active sessions by server name
+        """
+    def get_session_count(self) -> int:
+        """Get the number of active MCP sessions.
+
+        Returns:
+            Number of active persistent sessions
+        """

aip_agents/mcp/client/connection_manager.pyi

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+from aip_agents.mcp.client.transports import TransportType as TransportType, create_transport as create_transport
+from aip_agents.utils.logger import get_logger as get_logger
+from gllm_tools.mcp.client.config import MCPConfiguration
+from typing import Any
+
+logger: Incomplete
+
+class MCPConnectionManager:
+    """Manages MCP connection lifecycle following mcp-use patterns.
+
+    This connection manager handles the transport connection lifecycle in a background
+    task to avoid cancel scope issues during cleanup. It supports automatic transport
+    negotiation (HTTP -> SSE fallback) and graceful shutdown. Invalid explicit transports
+    are normalized via aliases (e.g., 'streamable_http' -> 'http') or fall back to
+    auto-detection with a warning.
+    """
+    TRANSPORT_ALIASES: Incomplete
+    server_name: Incomplete
+    config: Incomplete
+    transport_type: Incomplete
+    max_retries: Incomplete
+    initial_retry_delay: Incomplete
+    def __init__(self, server_name: str, config: MCPConfiguration) -> None:
+        """Initialize connection manager.
+
+        Args:
+            server_name (str): Name of the MCP server
+            config (MCPConfiguration): MCP server configuration
+        """
+    async def start(self) -> tuple[Any, Any]:
+        """Start connection in background task.
+
+        Returns:
+            tuple[Any, Any]: Tuple of (read_stream, write_stream) for ClientSession
+
+        Raises:
+            Exception: If connection establishment fails
+        """
+    async def stop(self) -> None:
+        """Stop connection gracefully."""
+    @property
+    def is_connected(self) -> bool:
+        """Check if connection is active.
+
+        Returns:
+            bool: True if connected, False otherwise
+        """

aip_agents/mcp/client/google_adk/__init__.pyi

@@ -1,3 +1,3 @@
-from .client import GoogleADKMCPClient as GoogleADKMCPClient
+from aip_agents.mcp.client.google_adk.client import GoogleADKMCPClient as GoogleADKMCPClient
 
 __all__ = ['GoogleADKMCPClient']

aip_agents/mcp/client/google_adk/client.pyi

@@ -1,27 +1,29 @@
-from gllm_tools.mcp.client.client import MCPClient
+from _typeshed import Incomplete
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.utils.logger import get_logger as get_logger
 from gllm_tools.mcp.client.config import MCPConfiguration as MCPConfiguration
-from gllm_tools.mcp.client.resource import MCPResource as MCPResource
-from gllm_tools.mcp.client.tool import MCPTool as MCPTool
-from mcp.types import CallToolResult as CallToolResult, EmbeddedResource, ImageContent
+from google.adk.tools import FunctionTool
+from mcp.types import EmbeddedResource, ImageContent
 
 NonTextContent = ImageContent | EmbeddedResource
+logger: Incomplete
 
-class GoogleADKMCPClient(MCPClient):
-    '''Google ADK MCP Client.
+class GoogleADKMCPClient(BaseMCPClient):
+    '''Google ADK MCP Client with Persistent Sessions.
 
-    This client is a wrapper around the MCPClient that converts MCP tools and resources
-    into Google ADK-compatible FunctionTool instances and resources. It enables seamless
-    integration between MCP servers and ADK agents.
+    This client extends BaseMCPClient to provide Google ADK-specific tool conversion
+    while maintaining persistent MCP sessions and connection reuse across tool calls.
+    It converts MCP tools into ADK FunctionTool instances for seamless integration.
 
     The client handles:
-    - Converting MCP tools to ADK FunctionTool instances
-    - Managing MCP server sessions and connections
+    - Converting MCP tools to ADK FunctionTool instances using persistent sessions
+    - Managing MCP server connections with automatic reconnection
     - Converting MCP resources to ADK-compatible formats
-    - Handling tool execution and response formatting
+    - Handling tool execution with proper error formatting for ADK agents
 
     Example:
         ```python
-        from gllm_tools.mcp.client.google_adk import GoogleADKMCPClient
+        from aip_agents.mcp.client.google_adk.client import GoogleADKMCPClient
         from gllm_tools.mcp.client.config import MCPConfiguration
 
         servers = {
@@ -32,7 +34,42 @@ class GoogleADKMCPClient(MCPClient):
         }
 
         client = GoogleADKMCPClient(servers)
+        await client.initialize()  # Initialize persistent sessions
         tools = await client.get_tools()  # Returns list of ADK FunctionTool instances
         ```
     '''
     RESOURCE_FETCH_TIMEOUT: int
+    def __init__(self, servers: dict[str, MCPConfiguration]) -> None:
+        """Initialize Google ADK MCP client.
+
+        Args:
+            servers (dict[str, MCPConfiguration]): Dictionary of MCP server configurations
+        """
+    async def initialize(self) -> None:
+        """Initialize persistent MCP sessions for Google ADK integration.
+
+        This method ensures all MCP servers are connected with persistent sessions
+        and prepares the client for ADK tool conversion.
+
+        Raises:
+            Exception: If session initialization fails
+        """
+    async def get_tools(self, server: str | None = None) -> list[FunctionTool]:
+        """Get ADK-compatible FunctionTool instances with smart caching.
+
+        Converts MCP tools to ADK format and caches them for better performance
+        on repeated access. Cache is keyed by server parameter.
+
+        Args:
+            server (str | None): Optional server name to filter tools from a specific server.
+                    If None, returns tools from all configured servers.
+
+        Returns:
+            list[FunctionTool]: List of cached ADK FunctionTool instances.
+        """
+    async def cleanup(self) -> None:
+        """Clean up Google ADK MCP client resources.
+
+        This method ensures all persistent sessions are properly closed and
+        ADK-specific resources are cleaned up.
+        """

aip_agents/mcp/client/langchain/__init__.pyi

@@ -1,3 +1,3 @@
-from .client import LangchainMCPClient as LangchainMCPClient
+from aip_agents.mcp.client.langchain.client import LangchainMCPClient as LangchainMCPClient
 
 __all__ = ['LangchainMCPClient']

aip_agents/mcp/client/langchain/client.pyi

@@ -1,3 +1,48 @@
-from gllm_tools.mcp.client.langchain.client import LangchainMCPClient as LangchainMCPClient
+from _typeshed import Incomplete
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.utils.logger import get_logger as get_logger
+from gllm_tools.mcp.client.config import MCPConfiguration as MCPConfiguration
+from langchain_core.tools import StructuredTool
+from mcp.types import EmbeddedResource, ImageContent
 
-__all__ = ['LangchainMCPClient']
+NonTextContent = ImageContent | EmbeddedResource
+logger: Incomplete
+
+class LangchainMCPClient(BaseMCPClient):
+    """Langchain MCP Client with Session Persistence.
+
+    This client extends BaseMCPClient to provide LangChain-specific tool conversion
+    while maintaining persistent MCP sessions and connection reuse across tool calls.
+    """
+    RESOURCE_FETCH_TIMEOUT: int
+    def __init__(self, servers: dict[str, MCPConfiguration]) -> None:
+        """Initialize LangChain MCP client.
+
+        Args:
+            servers (dict[str, MCPConfiguration]): Dictionary of MCP server configurations
+        """
+    async def initialize(self) -> None:
+        """Initialize all sessions for LangChain client.
+
+        This method initializes the base MCP sessions and prepares for tool caching.
+
+        Raises:
+            Exception: If base initialization fails
+        """
+    async def get_tools(self, server: str | None = None) -> list[StructuredTool]:
+        """Get LangChain StructuredTools with smart caching.
+
+        Converts MCP tools to LangChain format and caches them for better performance
+        on repeated access. Cache is keyed by server parameter.
+
+        Args:
+            server (str | None): Optional server name to filter tools. If None, returns all tools.
+
+        Returns:
+            list[StructuredTool]: List of cached LangChain StructuredTool instances
+        """
+    async def cleanup(self) -> None:
+        """Cleanup LangChain MCP resources.
+
+        This method extends base class cleanup and clears the LangChain tool cache.
+        """