clap-agents 0.1.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

clap/__init__.py

@@ -1,57 +1,28 @@
-# --- Example content for src/clap/__init__.py ---
-
-# Import key classes/functions from submodules to make them accessible at the top level
-
-# Multi-agent pattern
 from .multiagent_pattern.agent import Agent
 from .multiagent_pattern.team import Team
-
-# ReAct pattern
 from .react_pattern.react_agent import ReactAgent
-
-# Tool pattern
-from .tool_pattern.tool import tool, Tool
 from .tool_pattern.tool_agent import ToolAgent
+from .tool_pattern.tool import tool, Tool
 
-# LLM Services (Interface and implementations)
 from .llm_services.base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
 from .llm_services.groq_service import GroqService
 from .llm_services.google_openai_compat_service import GoogleOpenAICompatService
 
-from .mcp_client.client import MCPClientManager, SseServerConfig 
+from .embedding.base_embedding import EmbeddingFunctionInterface
 
+from .vector_stores.base import VectorStoreInterface, QueryResult
 
-from .tools.web_search import duckduckgo_search
-from .tools.web_crawler import scrape_url, extract_text_by_query
-from .tools.email_tools import send_email, fetch_recent_emails
+from .mcp_client.client import MCPClientManager, SseServerConfig
 
-__all__ = [
-    # Core classes
-    "Agent",
-    "Team",
-    "ReactAgent",
-    "ToolAgent",
-    "Tool",
-    "tool", # The decorator
-
-    # LLM Services
-    "LLMServiceInterface",
-    "StandardizedLLMResponse",
-    "LLMToolCall",
-    "GroqService",
-    "GoogleOpenAICompatService",
+from .tools.web_search import duckduckgo_search
 
-    # MCP Client
-    "MCPClientManager",
-    "SseServerConfig", # Expose config type
 
-    # Selected Tools (example)
+__all__ = [
+    "Agent", "Team", "ReactAgent", "ToolAgent", "Tool", "tool",
+    "LLMServiceInterface", "StandardizedLLMResponse", "LLMToolCall",
+    "GroqService", "GoogleOpenAICompatService",
+    "EmbeddingFunctionInterface", "SentenceTransformerEmbeddings",
+    "VectorStoreInterface", "QueryResult",
+    "MCPClientManager", "SseServerConfig",
     "duckduckgo_search",
-    # Add others from .tools if desired as part of the core offering
-]
-
-# You might also want to define a package-level version variable here
-# (though often handled by build tools or version files)
-# __version__ = "0.1.0"
-
-# --- End of src/clap/__init__.py ---
+]

clap/embedding/__init__.py

@@ -0,0 +1,21 @@
+from .base_embedding import EmbeddingFunctionInterface
+
+__all__ = ["EmbeddingFunctionInterface"]
+
+try:
+    from .sentence_transformer_embedding import SentenceTransformerEmbeddings
+    __all__.append("SentenceTransformerEmbeddings")
+except ImportError:
+    pass
+
+try:
+    from .fastembed_embedding import FastEmbedEmbeddings
+    __all__.append("FastEmbedEmbeddings")
+except ImportError:
+    pass
+
+try:
+    from .ollama_embedding import OllamaEmbeddings
+    __all__.append("OllamaEmbeddings")
+except ImportError:
+    pass

clap/embedding/base_embedding.py

@@ -0,0 +1,28 @@
+import abc
+from typing import List, Protocol
+
+class EmbeddingFunctionInterface(Protocol):
+    """
+    A protocol for embedding functions to ensure they can provide
+    their output dimensionality and embed documents.
+    """
+
+    @abc.abstractmethod
+    def __call__(self, input: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of texts.
+
+        Args:
+            input: A list of document texts.
+
+        Returns:
+            A list of embeddings (list of floats).
+        """
+        ...
+
+    @abc.abstractmethod
+    def get_embedding_dimension(self) -> int:
+        """
+        Returns the dimensionality of the embeddings produced by this function.
+        """
+        ...

clap/embedding/fastembed_embedding.py

@@ -0,0 +1,75 @@
+import asyncio
+import functools
+from typing import List, Optional, Any, cast
+
+import anyio
+
+from .base_embedding import EmbeddingFunctionInterface
+
+_FASTEMBED_LIB_AVAILABLE = False
+_FastEmbed_TextEmbedding_Placeholder_Type = Any 
+
+try:
+    from fastembed import TextEmbedding as ActualTextEmbedding
+    _FastEmbed_TextEmbedding_Placeholder_Type = ActualTextEmbedding
+    _FASTEMBED_LIB_AVAILABLE = True
+except ImportError:
+    pass
+
+KNOWN_FASTEMBED_DIMENSIONS = {
+    "BAAI/bge-small-en-v1.5": 384,
+    "sentence-transformers/all-MiniLM-L6-v2": 384,
+}
+DEFAULT_FASTEMBED_MODEL = "BAAI/bge-small-en-v1.5"
+
+class FastEmbedEmbeddings(EmbeddingFunctionInterface):
+    _model: _FastEmbed_TextEmbedding_Placeholder_Type
+    _dimension: int
+    DEFAULT_EMBED_BATCH_SIZE = 256
+
+    def __init__(self,
+                 model_name: str = DEFAULT_FASTEMBED_MODEL,
+                 dimension: Optional[int] = None,
+                 embed_batch_size: int = DEFAULT_EMBED_BATCH_SIZE,
+                 **kwargs: Any
+                ):
+        if not _FASTEMBED_LIB_AVAILABLE:
+            raise ImportError(
+                "The 'fastembed' library is required to use FastEmbedEmbeddings. "
+                "Install with 'pip install fastembed' or 'pip install \"clap-agents[qdrant]\"' (if qdrant includes it as an extra)."
+            )
+
+        self.model_name = model_name
+        self.embed_batch_size = embed_batch_size
+
+        if dimension is not None:
+            self._dimension = dimension
+        elif model_name in KNOWN_FASTEMBED_DIMENSIONS:
+            self._dimension = KNOWN_FASTEMBED_DIMENSIONS[model_name]
+        else:
+            raise ValueError(
+                f"Dimension for fastembed model '{self.model_name}' is unknown. "
+                "Provide 'dimension' parameter or update KNOWN_FASTEMBED_DIMENSIONS."
+            )
+        
+        try:
+            self._model = _FastEmbed_TextEmbedding_Placeholder_Type(model_name=self.model_name, **kwargs)
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize fastembed model '{self.model_name}': {e}")
+
+    async def __call__(self, input: List[str]) -> List[List[float]]: # Changed to 'input'
+        if not input: return []
+        if not _FASTEMBED_LIB_AVAILABLE: raise RuntimeError("FastEmbed library not available.")
+        
+        all_embeddings_list: List[List[float]] = []
+        for i in range(0, len(input), self.embed_batch_size):
+            batch_texts = input[i:i + self.embed_batch_size]
+            if not batch_texts: continue
+            try:
+                embeddings_iterable = await anyio.to_thread.run_sync(self._model.embed, list(batch_texts))
+                for emb_np in embeddings_iterable: all_embeddings_list.append(emb_np.tolist())
+            except Exception as e: print(f"Error embedding batch with fastembed: {e}"); raise
+        return all_embeddings_list
+
+    def get_embedding_dimension(self) -> int:
+        return self._dimension

clap/embedding/ollama_embedding.py

@@ -0,0 +1,76 @@
+import asyncio
+import functools
+from typing import List, Optional, Any, cast
+
+import anyio
+
+from .base_embedding import EmbeddingFunctionInterface
+
+_OLLAMA_LIB_AVAILABLE = False
+_OllamaAsyncClient_Placeholder_Type = Any
+_OllamaResponseError_Placeholder_Type = type(Exception)
+
+try:
+    from ollama import AsyncClient as ImportedOllamaAsyncClient
+    from ollama import ResponseError as ImportedOllamaResponseError
+    _OllamaAsyncClient_Placeholder_Type = ImportedOllamaAsyncClient
+    _OllamaResponseError_Placeholder_Type = ImportedOllamaResponseError
+    _OLLAMA_LIB_AVAILABLE = True
+except ImportError:
+    pass
+
+KNOWN_OLLAMA_EMBEDDING_DIMENSIONS = {
+    "nomic-embed-text": 768, "mxbai-embed-large": 1024, "all-minilm": 384,
+    "llama3": 4096, "llama3.2:latest": 4096, "nomic-embed-text:latest": 768,
+}
+DEFAULT_OLLAMA_EMBED_MODEL = "nomic-embed-text"
+
+class OllamaEmbeddings(EmbeddingFunctionInterface):
+    _client: _OllamaAsyncClient_Placeholder_Type
+    _model_name: str
+    _dimension: int
+
+    def __init__(self,
+                 model_name: str = DEFAULT_OLLAMA_EMBED_MODEL,
+                 dimension: Optional[int] = None,
+                 ollama_host: str = "http://localhost:11434",
+                 **kwargs: Any):
+        if not _OLLAMA_LIB_AVAILABLE:
+            raise ImportError("The 'ollama' Python library is required. Install with: pip install 'clap-agents[ollama]'")
+
+        self.model_name = model_name
+        self._client = _OllamaAsyncClient_Placeholder_Type(host=ollama_host, **kwargs)
+
+        if dimension is not None: self._dimension = dimension
+        elif model_name in KNOWN_OLLAMA_EMBEDDING_DIMENSIONS:
+            self._dimension = KNOWN_OLLAMA_EMBEDDING_DIMENSIONS[model_name]
+        else:
+            raise ValueError(f"Dimension for Ollama model '{model_name}' unknown. Provide 'dimension' or update KNOWN_OLLAMA_EMBEDDING_DIMENSIONS.")
+        print(f"Initialized OllamaEmbeddings for model '{self.model_name}' (dim: {self._dimension}).")
+
+    async def __call__(self, input: List[str]) -> List[List[float]]: 
+        if not input: return []
+        if not _OLLAMA_LIB_AVAILABLE: raise RuntimeError("Ollama library not available.")
+        try:
+            response = await self._client.embed(model=self.model_name, input=input) 
+            embeddings_data = response.get("embeddings")
+            if embeddings_data is None and len(input) == 1 and response.get("embedding"):
+                single_embedding = response.get("embedding")
+                if isinstance(single_embedding, list) and all(isinstance(x, (int, float)) for x in single_embedding):
+                    embeddings_data = [single_embedding]
+            if not isinstance(embeddings_data, list) or not all(isinstance(e, list) for e in embeddings_data):
+                raise TypeError(f"Ollama embed returned unexpected format. Expected List[List[float]]. Resp: {response}")
+            return cast(List[List[float]], embeddings_data)
+        except _OllamaResponseError_Placeholder_Type as e:
+            print(f"Ollama API error: {getattr(e, 'error', str(e))} (Status: {getattr(e, 'status_code', 'N/A')})")
+            raise
+        except Exception as e: print(f"Unexpected Ollama embedding error: {e}"); raise
+
+    def get_embedding_dimension(self) -> int: return self._dimension
+
+    async def close(self):
+        if _OLLAMA_LIB_AVAILABLE:
+            if hasattr(self._client, "_client") and hasattr(self._client._client, "is_closed"):
+                if not self._client._client.is_closed: await self._client._client.aclose() 
+            elif hasattr(self._client, 'aclose'): await self._client.aclose() 
+        print(f"OllamaEmbeddings: Closed client for {self.model_name}.")

clap/embedding/sentence_transformer_embedding.py

@@ -0,0 +1,44 @@
+from typing import List, Optional, Any 
+from .base_embedding import EmbeddingFunctionInterface
+
+_ST_LIB_AVAILABLE = False
+_SentenceTransformer_Placeholder_Type = Any 
+
+try:
+    from sentence_transformers import SentenceTransformer as ImportedSentenceTransformer
+    _SentenceTransformer_Placeholder_Type = ImportedSentenceTransformer
+    _ST_LIB_AVAILABLE = True
+except ImportError:
+    pass
+
+class SentenceTransformerEmbeddings(EmbeddingFunctionInterface):
+    model: _SentenceTransformer_Placeholder_Type
+    _dimension: int
+
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2", device: Optional[str] = None):
+        if not _ST_LIB_AVAILABLE:
+            raise ImportError(
+                "The 'sentence-transformers' library is required to use SentenceTransformerEmbeddings. "
+                "Install with 'pip install sentence-transformers' or 'pip install \"clap-agents[sentence-transformers]\"'."
+            )
+        
+        try:
+            self.model = _SentenceTransformer_Placeholder_Type(model_name, device=device)
+            dim = self.model.get_sentence_embedding_dimension() 
+            if dim is None: 
+                dummy_embedding = self.model.encode("test") 
+                dim = len(dummy_embedding)
+            self._dimension = dim
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize SentenceTransformer model '{model_name}': {e}")
+
+
+
+    def __call__(self, input: List[str]) -> List[List[float]]: 
+        if not _ST_LIB_AVAILABLE: 
+            raise RuntimeError("SentenceTransformers library not available for embedding operation.")
+        embeddings_np = self.model.encode(input, convert_to_numpy=True) 
+        return embeddings_np.tolist()
+
+    def get_embedding_dimension(self) -> int:
+        return self._dimension

clap/llm_services/__init__.py

@@ -0,0 +1,15 @@
+# src/clap/llm_services/__init__.py
+from .base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
+from .groq_service import GroqService
+from .google_openai_compat_service import GoogleOpenAICompatService
+
+__all__ = [
+    "LLMServiceInterface", "StandardizedLLMResponse", "LLMToolCall",
+    "GroqService", "GoogleOpenAICompatService",
+]
+
+try:
+    from .ollama_service import OllamaOpenAICompatService as OllamaService # Assuming file is ollama_service.py
+    __all__.append("OllamaService")
+except ImportError:
+    pass

clap/llm_services/base.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Optional, Union
 @dataclass
 class LLMToolCall:
     """Represents a tool call requested by the LLM."""
-    id: str # The unique ID for this specific tool call instance
+    id: str 
     function_name: str
     function_arguments_json_str: str
 
@@ -32,7 +32,7 @@ class LLMServiceInterface(abc.ABC):
         messages: List[Dict[str, Any]],
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: str = "auto",
-        # Optional: Add other common configuration parameters if needed later
+        # Optional: 
         # temperature: Optional[float] = None,
         # max_tokens: Optional[int] = None,
     ) -> StandardizedLLMResponse:
@@ -61,8 +61,5 @@ class LLMServiceInterface(abc.ABC):
         """
         pass
 
-    # Optional: Add other common methods if needed, e.g., for embedding generation
-    # @abc.abstractmethod
-    # async def get_embedding(self, text: str, model: str) -> List[float]:
-    #     pass
+   
 

clap/llm_services/google_openai_compat_service.py

@@ -5,7 +5,6 @@ import json
 import uuid 
 from typing import Any, Dict, List, Optional
 
-# Import the OpenAI library
 try:
     from openai import AsyncOpenAI, OpenAIError
 except ImportError:
@@ -13,10 +12,8 @@ except ImportError:
 
 from colorama import Fore
 
-# Import the base interface and response structures
 from .base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
 
-# Google's OpenAI-compatible endpoint
 GOOGLE_COMPAT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
 
 class GoogleOpenAICompatService(LLMServiceInterface):
@@ -95,7 +92,7 @@ class GoogleOpenAICompatService(LLMServiceInterface):
                 for tc in message.tool_calls:
                     tool_call_id = getattr(tc, 'id', None)
                     if not tool_call_id:
-                        tool_call_id = f"compat_call_{uuid.uuid4().hex[:6]}" # Use uuid here
+                        tool_call_id = f"compat_call_{uuid.uuid4().hex[:6]}" 
                         print(f"{Fore.YELLOW}Warning: Tool call from Google compat layer missing ID. Generated fallback: {tool_call_id}{Fore.RESET}")
 
                     if tc.function:
@@ -119,4 +116,3 @@ class GoogleOpenAICompatService(LLMServiceInterface):
             print(f"{Fore.RED}Error calling Google (via OpenAI Compat Layer) LLM API: {e}{Fore.RESET}")
             raise
 
-# --- END OF agentic_patterns/llm_services/google_openai_compat_service.py ---

clap/llm_services/groq_service.py

@@ -1,11 +1,9 @@
-# --- START OF agentic_patterns/llm_services/groq_service.py ---
 
 from typing import Any, Dict, List, Optional
 
-from groq import AsyncGroq, GroqError # Import AsyncGroq and potential errors
-from colorama import Fore # For error printing
+from groq import AsyncGroq, GroqError 
+from colorama import Fore 
 
-# Import the base interface and response structures
 from .base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
 
 class GroqService(LLMServiceInterface):
@@ -60,17 +58,15 @@ class GroqService(LLMServiceInterface):
                 api_kwargs["tools"] = tools
                 api_kwargs["tool_choice"] = tool_choice
 
-            # Call the Groq API asynchronously using the correct method name
             response = await self.client.chat.completions.create(**api_kwargs)
 
-            # Process the response
             message = response.choices[0].message
             text_content = message.content
             tool_calls: List[LLMToolCall] = []
 
             if message.tool_calls:
                 for tc in message.tool_calls:
-                    if tc.function: # Check if function attribute exists
+                    if tc.function: 
                         tool_calls.append(
                             LLMToolCall(
                                 id=tc.id,
@@ -86,15 +82,11 @@ class GroqService(LLMServiceInterface):
             )
 
         except GroqError as e:
-            # Catch specific Groq errors for potentially better handling
             print(f"{Fore.RED}Groq API Error: {e}{Fore.RESET}")
-            # Re-raise or handle as needed, maybe return an error response?
-            # For now, re-raise to signal failure clearly
+            
             raise
         except Exception as e:
             print(f"{Fore.RED}Error calling Groq LLM API: {e}{Fore.RESET}")
-            # Depending on desired behavior, could return a StandardizedLLMResponse
-            # with error info in text_content, or re-raise. Re-raising is cleaner.
+            
             raise
 
-# --- END OF agentic_patterns/llm_services/groq_service.py ---

clap/llm_services/ollama_service.py

@@ -0,0 +1,101 @@
+import os
+import json
+import uuid
+from typing import Any, Dict, List, Optional
+
+_OPENAI_LIB_AVAILABLE = False
+_AsyncOpenAI_Placeholder_Type = Any
+_OpenAIError_Placeholder_Type = type(Exception)
+
+try:
+    from openai import AsyncOpenAI as ImportedAsyncOpenAI, OpenAIError as ImportedOpenAIError
+    _AsyncOpenAI_Placeholder_Type = ImportedAsyncOpenAI
+    _OpenAIError_Placeholder_Type = ImportedOpenAIError
+    _OPENAI_LIB_AVAILABLE = True
+except ImportError:
+    pass
+
+from colorama import Fore
+from .base import LLMServiceInterface, StandardizedLLMResponse, LLMToolCall
+
+OLLAMA_OPENAI_COMPAT_BASE_URL = "http://localhost:11434/v1"
+
+class OllamaOpenAICompatService(LLMServiceInterface): 
+    """
+    LLM Service implementation using the OpenAI SDK configured for a
+    local Ollama instance's OpenAI-compatible API.
+    """
+    _client: _AsyncOpenAI_Placeholder_Type
+
+    def __init__(
+        self,
+        base_url: str = OLLAMA_OPENAI_COMPAT_BASE_URL,
+        api_key: str = "ollama", # Dummy
+        default_model: Optional[str] = None
+    ):
+
+        """
+        Initializes the service using the OpenAI client pointed at Ollama.
+
+        Args:
+            base_url: The base URL for the Ollama OpenAI compatibility endpoint.
+            api_key: Dummy API key for the OpenAI client (Ollama ignores it).
+            default_model: Optional default Ollama model name to use if not specified in calls.
+        """
+        if not _OPENAI_LIB_AVAILABLE:
+            raise ImportError(
+                "The 'openai' Python library is required to use OllamaOpenAICompatService. "
+                "Install with 'pip install openai' or 'pip install \"clap-agents[ollama]\"' (if ollama extra includes openai)."
+            )
+        self.default_model = default_model
+        try:
+            self._client = _AsyncOpenAI_Placeholder_Type(base_url=base_url, api_key=api_key)
+            # print(f"OllamaService: Initialized OpenAI client for Ollama at {base_url}")
+        except Exception as e:
+            print(f"{Fore.RED}Failed to initialize OpenAI client for Ollama: {e}{Fore.RESET}"); raise
+
+    async def get_llm_response(self, model: str, messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]] = None, tool_choice: str = "auto", temperature: Optional[float] = None, max_tokens: Optional[int] = None) -> StandardizedLLMResponse:
+        """
+        Sends messages via the OpenAI SDK (to Ollama's endpoint)
+        and returns a standardized response.
+        """
+        if not _OPENAI_LIB_AVAILABLE: raise RuntimeError("OpenAI library not available for Ollama service.")
+        request_model = model or self.default_model
+        if not request_model: raise ValueError("Ollama model name not specified.")
+        try:
+            api_kwargs: Dict[str, Any] = {"messages": messages, "model": request_model}
+            if tools and tool_choice != "none":
+                api_kwargs["tools"] = tools
+                if isinstance(tool_choice, dict) or tool_choice in ["auto", "required", "none"]: api_kwargs["tool_choice"] = tool_choice
+            else: api_kwargs["tools"] = None; api_kwargs["tool_choice"] = None
+            if temperature is not None: api_kwargs["temperature"] = temperature
+            if max_tokens is not None: api_kwargs["max_tokens"] = max_tokens
+            api_kwargs = {k: v for k, v in api_kwargs.items() if v is not None}
+            # print(f"OllamaService: Sending request to model '{request_model}'")
+            response = await self._client.chat.completions.create(**api_kwargs)
+            message = response.choices[0].message
+            text_content = message.content
+            tool_calls_std: List[LLMToolCall] = []
+            if message.tool_calls:
+                for tc in message.tool_calls:
+                    if tc.id and tc.function and tc.function.name and tc.function.arguments is not None:
+                        tool_calls_std.append(LLMToolCall(id=tc.id, function_name=tc.function.name, function_arguments_json_str=tc.function.arguments))
+                    else: print(f"{Fore.YELLOW}Warning: Incomplete tool_call from Ollama: {tc}{Fore.RESET}")
+            return StandardizedLLMResponse(text_content=text_content, tool_calls=tool_calls_std)
+        except _OpenAIError_Placeholder_Type as e: # Use placeholder
+            err_msg = f"Ollama (OpenAI Compat) API Error: {e}"
+            if hasattr(e, 'response') and e.response and hasattr(e.response, 'text'): err_msg += f" - Details: {e.response.text}"
+            print(f"{Fore.RED}{err_msg}{Fore.RESET}")
+            return StandardizedLLMResponse(text_content=err_msg)
+        except Exception as e:
+            print(f"{Fore.RED}Unexpected error with Ollama (OpenAI Compat): {e}{Fore.RESET}")
+            return StandardizedLLMResponse(text_content=f"Ollama Unexpected Error: {e}")
+
+
+    async def close(self):
+        if _OPENAI_LIB_AVAILABLE and hasattr(self, '_client') and self._client:
+            if hasattr(self._client, "close"): await self._client.close() # For openai >1.0
+            elif hasattr(self._client, "_client") and hasattr(self._client._client, "is_closed"): # For httpx client in openai <1.0
+                 if not self._client._client.is_closed: await self._client._client.aclose() # type: ignore
+        # print("OllamaService: Client closed.")
+# --- END OF FILE ---

clap/mcp_client/client.py

@@ -1,29 +1,20 @@
-# --- START OF agentic_patterns/mcp_client/client.py (SSE Version) ---
 
 import asyncio
 import json
 from contextlib import AsyncExitStack
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, HttpUrl # Import HttpUrl
+from pydantic import BaseModel, Field, HttpUrl 
 
-# Imports from MCP SDK
 from mcp import ClientSession, types
-# Import sse_client instead of stdio_client
 from mcp.client.sse import sse_client
-# For logging/coloring output
 from colorama import Fore
 
-# Configuration model for a single SSE server
 class SseServerConfig(BaseModel):
     """Configuration for connecting to an MCP server via SSE."""
-    # Expecting a URL like http://host:port (base URL)
-    # The sse_client will likely append the standard /sse path
     url: HttpUrl = Field(description="The base URL of the MCP SSE server.")
-    # Optional headers if needed for authentication etc.
     headers: Optional[Dict[str, str]] = Field(default=None, description="Optional headers for the connection.")
 
-# Manager class focused on SSE
 class MCPClientManager:
     """
     Manages connections and interactions with multiple MCP servers via SSE.
@@ -79,24 +70,22 @@ class MCPClientManager:
             print(f"{Fore.YELLOW}Attempting to connect to MCP server via SSE: {server_name} at {config.url}{Fore.RESET}")
 
             # Construct the specific SSE endpoint URL (often /sse)
-            # Assuming the base URL is provided in config.url
-            sse_url = str(config.url).rstrip('/') + "/sse" # Standard convention
+            sse_url = str(config.url).rstrip('/') + "/sse" 
 
             exit_stack = AsyncExitStack()
             try:
-                # Establish SSE transport
-                # Pass headers if provided in config
+                
                 sse_transport = await exit_stack.enter_async_context(
                     sse_client(url=sse_url, headers=config.headers)
                 )
                 read_stream, write_stream = sse_transport
 
-                # Establish MCP session
+                
                 session = await exit_stack.enter_async_context(
                     ClientSession(read_stream, write_stream)
                 )
 
-                # Initialize session
+                
                 await session.initialize()
 
                 async with self._manager_lock:
@@ -124,14 +113,16 @@ class MCPClientManager:
                  await exit_stack.aclose()
                  print(f"{Fore.GREEN}Disconnected from MCP server: {server_name}{Fore.RESET}")
 
+        
     async def disconnect_all(self):
-        """Disconnects from all currently connected servers."""
         server_names = list(self.sessions.keys())
-        print(f"{Fore.YELLOW}Disconnecting from all servers: {server_names}{Fore.RESET}")
-        # Use asyncio.gather for concurrent disconnection
-        tasks = [self.disconnect(name) for name in server_names]
-        await asyncio.gather(*tasks, return_exceptions=True) # Handle errors during disconnect
-        print(f"{Fore.GREEN}Finished disconnecting all servers.{Fore.RESET}")
+        print(f"{Fore.YELLOW}MCPClientManager: Disconnecting from all servers ({len(server_names)})...{Fore.RESET}")
+        for name in server_names:
+            try:
+                await self.disconnect(name)
+            except Exception as e:
+                print(f"{Fore.RED}MCPClientManager: Error during disconnect of '{name}': {e}{Fore.RESET}")
+        print(f"{Fore.GREEN}MCPClientManager: Finished disconnecting all servers.{Fore.RESET}")
 
     async def list_remote_tools(self, server_name: str) -> List[types.Tool]:
         """
@@ -190,7 +181,6 @@ class MCPClientManager:
                   for content_item in result.content:
                       if isinstance(content_item, types.TextContent):
                           response_parts.append(content_item.text)
-                      # Add handling for other content types if needed later
                       elif isinstance(content_item, types.ImageContent):
                            response_parts.append(f"[Image Content Received: {content_item.mimeType}]")
                       elif isinstance(content_item, types.EmbeddedResource):
@@ -204,5 +194,3 @@ class MCPClientManager:
         except Exception as e:
              print(f"{Fore.RED}Error calling tool '{tool_name}' on server '{server_name}': {e}{Fore.RESET}")
              raise RuntimeError(f"Failed to call tool '{tool_name}' on '{server_name}'.") from e
-
-# --- END OF agentic_patterns/mcp_client/client.py (SSE Version) ---