universal-mcp 0.1.15rc5__py3-none-any.whl → 0.1.16__py3-none-any.whl

universal_mcp/config.py

@@ -12,9 +12,7 @@ class StoreConfig(BaseModel):
     type: Literal["memory", "environment", "keyring", "agentr"] = Field(
         default="memory", description="Type of credential storage to use"
     )
-    path: Path | None = Field(
-        default=None, description="Path to store credentials (if applicable)"
-    )
+    path: Path | None = Field(default=None, description="Path to store credentials (if applicable)")
 
 
 class IntegrationConfig(BaseModel):
@@ -24,24 +22,16 @@ class IntegrationConfig(BaseModel):
     type: Literal["api_key", "oauth", "agentr", "oauth2"] = Field(
         default="api_key", description="Type of authentication to use"
     )
-    credentials: dict[str, Any] | None = Field(
-        default=None, description="Integration-specific credentials"
-    )
-    store: StoreConfig | None = Field(
-        default=None, description="Store configuration for credentials"
-    )
+    credentials: dict[str, Any] | None = Field(default=None, description="Integration-specific credentials")
+    store: StoreConfig | None = Field(default=None, description="Store configuration for credentials")
 
 
 class AppConfig(BaseModel):
     """Configuration for individual applications."""
 
     name: str = Field(..., description="Name of the application")
-    integration: IntegrationConfig | None = Field(
-        default=None, description="Integration configuration"
-    )
-    actions: list[str] | None = Field(
-        default=None, description="List of available actions"
-    )
+    integration: IntegrationConfig | None = Field(default=None, description="Integration configuration")
+    actions: list[str] | None = Field(default=None, description="List of available actions")
 
 
 class ServerConfig(BaseSettings):
@@ -56,46 +46,24 @@ class ServerConfig(BaseSettings):
     )
 
     name: str = Field(default="Universal MCP", description="Name of the MCP server")
-    description: str = Field(
-        default="Universal MCP", description="Description of the MCP server"
-    )
-    api_key: SecretStr | None = Field(
-        default=None, description="API key for authentication"
-    )
-    type: Literal["local", "agentr"] = Field(
-        default="agentr", description="Type of server deployment"
-    )
-    transport: Literal["stdio", "sse", "http"] = Field(
-        default="stdio", description="Transport protocol to use"
-    )
-    port: int = Field(
-        default=8005, description="Port to run the server on (if applicable)"
-    )
-    host: str = Field(
-        default="localhost", description="Host to bind the server to (if applicable)"
-    )
-    apps: list[AppConfig] | None = Field(
-        default=None, description="List of configured applications"
-    )
-    store: StoreConfig | None = Field(
-        default=None, description="Default store configuration"
-    )
+    description: str = Field(default="Universal MCP", description="Description of the MCP server")
+    api_key: SecretStr | None = Field(default=None, description="API key for authentication")
+    type: Literal["local", "agentr"] = Field(default="agentr", description="Type of server deployment")
+    transport: Literal["stdio", "sse", "http"] = Field(default="stdio", description="Transport protocol to use")
+    port: int = Field(default=8005, description="Port to run the server on (if applicable)")
+    host: str = Field(default="localhost", description="Host to bind the server to (if applicable)")
+    apps: list[AppConfig] | None = Field(default=None, description="List of configured applications")
+    store: StoreConfig | None = Field(default=None, description="Default store configuration")
     debug: bool = Field(default=False, description="Enable debug mode")
     log_level: str = Field(default="INFO", description="Logging level")
-    max_connections: int = Field(
-        default=100, description="Maximum number of concurrent connections"
-    )
-    request_timeout: int = Field(
-        default=60, description="Default request timeout in seconds"
-    )
+    max_connections: int = Field(default=100, description="Maximum number of concurrent connections")
+    request_timeout: int = Field(default=60, description="Default request timeout in seconds")
 
     @field_validator("log_level", mode="before")
     def validate_log_level(cls, v: str) -> str:
         valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
         if v.upper() not in valid_levels:
-            raise ValueError(
-                f"Invalid log level. Must be one of: {', '.join(valid_levels)}"
-            )
+            raise ValueError(f"Invalid log level. Must be one of: {', '.join(valid_levels)}")
         return v.upper()
 
     @field_validator("port", mode="before")

universal_mcp/exceptions.py

@@ -11,3 +11,11 @@ class ToolError(Exception):
 
 class InvalidSignature(Exception):
     """Raised when a signature is invalid."""
+
+
+class StoreError(Exception):
+    """Base exception class for store-related errors."""
+
+
+class KeyNotFoundError(StoreError):
+    """Exception raised when a key is not found in the store."""

universal_mcp/integrations/__init__.py

@@ -8,9 +8,7 @@ from universal_mcp.integrations.integration import (
 from universal_mcp.stores.store import BaseStore
 
 
-def integration_from_config(
-    config: IntegrationConfig, store: BaseStore | None = None, **kwargs
-) -> Integration:
+def integration_from_config(config: IntegrationConfig, store: BaseStore | None = None, **kwargs) -> Integration:
     if config.type == "api_key":
         return ApiKeyIntegration(config.name, store=store, **kwargs)
     elif config.type == "agentr":

universal_mcp/integrations/integration.py

@@ -6,7 +6,7 @@ from loguru import logger
 
 from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.stores import BaseStore
-from universal_mcp.stores.store import KeyNotFoundError
+from universal_mcp.stores.store import KeyNotFoundError, MemoryStore
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -91,7 +91,7 @@ class ApiKeyIntegration(Integration):
         store: Store instance for persisting credentials and other data
     """
 
-    def __init__(self, name: str, store: BaseStore | None = None, **kwargs):
+    def __init__(self, name: str, store: BaseStore = MemoryStore(), **kwargs):
         self.type = "api_key"
         sanitized_name = sanitize_api_key_name(name)
         super().__init__(sanitized_name, store, **kwargs)
@@ -109,6 +109,22 @@ class ApiKeyIntegration(Integration):
                 raise NotAuthorizedError(action) from e
         return self._api_key
 
+    @api_key.setter
+    def api_key(self, value: str | None) -> None:
+        """Set the API key.
+
+        Args:
+            value: The API key value to set.
+
+        Raises:
+            ValueError: If the API key is invalid.
+        """
+        if value is not None and not isinstance(value, str):
+            raise ValueError("API key must be a string")
+        self._api_key = value
+        if value is not None:
+            self.store.set(self.name, value)
+
     def get_credentials(self) -> dict[str, str]:
         """Get API key credentials.
 

universal_mcp/logger.py

@@ -5,6 +5,21 @@ from pathlib import Path
 from loguru import logger
 
 
+def get_log_file_path(app_name: str = "universal-mcp") -> Path:
+    """Get a standardized log file path for an application.
+
+    Args:
+        app_name: Name of the application.
+
+    Returns:
+        Path to the log file in the format: logs/{app_name}/{app_name}_{date}.log
+    """
+    date_str = datetime.now().strftime("%Y%m%d")
+    home = Path.home()
+    log_dir = home / ".universal-mcp" / "logs"
+    return log_dir / f"{app_name}_{date_str}.log"
+
+
 def setup_logger(
     log_file: Path | None = None,
     rotation: str = "10 MB",
@@ -35,34 +50,21 @@ def setup_logger(
         backtrace=True,
         diagnose=True,
     )
+    if not log_file:
+        log_file = get_log_file_path()
 
-    # Add file handler if log_file is specified
-    if log_file:
-        # Ensure log directory exists
-        log_file.parent.mkdir(parents=True, exist_ok=True)
-
-        logger.add(
-            sink=str(log_file),
-            rotation=rotation,
-            retention=retention,
-            compression=compression,
-            level=level,
-            format=format,
-            enqueue=True,
-            backtrace=True,
-            diagnose=True,
-        )
-
-
-def get_log_file_path(app_name: str) -> Path:
-    """Get a standardized log file path for an application.
+    # Ensure log directory exists
+    log_file.parent.mkdir(parents=True, exist_ok=True)
 
-    Args:
-        app_name: Name of the application.
-
-    Returns:
-        Path to the log file in the format: logs/{app_name}/{app_name}_{date}.log
-    """
-    date_str = datetime.now().strftime("%Y%m%d")
-    log_dir = Path("logs") / app_name
-    return log_dir / f"{app_name}_{date_str}.log"
+    logger.add(
+        sink=str(log_file),
+        rotation=rotation,
+        retention=retention,
+        compression=compression,
+        level=level,
+        format=format,
+        enqueue=True,
+        backtrace=True,
+        diagnose=True,
+    )
+    logger.info(f"Logging to {log_file}")

universal_mcp/servers/server.py

@@ -28,9 +28,7 @@ class BaseServer(FastMCP, ABC):
 
     def __init__(self, config: ServerConfig, **kwargs):
         super().__init__(config.name, config.description, port=config.port, **kwargs)
-        logger.info(
-            f"Initializing server: {config.name} ({config.type}) with store: {config.store}"
-        )
+        logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
 
         self.config = config  # Store config at base level for consistency
         self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
@@ -67,19 +65,13 @@ class BaseServer(FastMCP, ABC):
         """
         if isinstance(result, str):
             return [TextContent(type="text", text=result)]
-        elif isinstance(result, list) and all(
-            isinstance(item, TextContent) for item in result
-        ):
+        elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
             return result
         else:
-            logger.warning(
-                f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent."
-            )
+            logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
             return [TextContent(type="text", text=str(result))]
 
-    async def call_tool(
-        self, name: str, arguments: dict[str, Any]
-    ) -> list[TextContent]:
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
         """Call a tool with comprehensive error handling.
 
         Args:
@@ -139,9 +131,7 @@ class LocalServer(BaseServer):
         """
         try:
             integration = (
-                integration_from_config(app_config.integration, store=self.store)
-                if app_config.integration
-                else None
+                integration_from_config(app_config.integration, store=self.store) if app_config.integration else None
             )
             return app_from_slug(app_config.name)(integration=integration)
         except Exception as e:
@@ -200,9 +190,7 @@ class AgentRServer(BaseServer):
         """
         try:
             integration = (
-                AgentRIntegration(
-                    name=app_config.integration.name, api_key=self.client.api_key
-                )
+                AgentRIntegration(name=app_config.integration.name, api_key=self.client.api_key)
                 if app_config.integration
                 else None
             )

universal_mcp/stores/store.py

@@ -5,17 +5,7 @@ from typing import Any
 import keyring
 from loguru import logger
 
-
-class StoreError(Exception):
-    """Base exception class for store-related errors."""
-
-    pass
-
-
-class KeyNotFoundError(StoreError):
-    """Exception raised when a key is not found in the store."""
-
-    pass
+from universal_mcp.exceptions import KeyNotFoundError, StoreError
 
 
 class BaseStore(ABC):
@@ -84,7 +74,7 @@ class MemoryStore(BaseStore):
 
     def __init__(self):
         """Initialize an empty dictionary to store the data."""
-        self.data: dict[str, str] = {}
+        self.data: dict[str, Any] = {}
 
     def get(self, key: str) -> Any:
         """

universal_mcp/tools/__init__.py

@@ -1,4 +1,15 @@
+from .adapters import (
+    convert_tool_to_langchain_tool,
+    convert_tool_to_mcp_tool,
+    convert_tool_to_openai_tool,
+)
 from .manager import ToolManager
 from .tools import Tool
 
-__all__ = ["Tool", "ToolManager"]
+__all__ = [
+    "Tool",
+    "ToolManager",
+    "convert_tool_to_langchain_tool",
+    "convert_tool_to_openai_tool",
+    "convert_tool_to_mcp_tool",
+]

universal_mcp/tools/adapters.py

@@ -1,6 +1,16 @@
+from enum import Enum
+
 from universal_mcp.tools.tools import Tool
 
 
+class ToolFormat(str, Enum):
+    """Supported tool formats."""
+
+    MCP = "mcp"
+    LANGCHAIN = "langchain"
+    OPENAI = "openai"
+
+
 def convert_tool_to_mcp_tool(
     tool: Tool,
 ):
@@ -40,6 +50,7 @@ def convert_tool_to_langchain_tool(
         description=tool.description or "",
         coroutine=call_tool,
         response_format="content",
+        args_schema=tool.parameters,
     )
 
 

universal_mcp/tools/func_metadata.py

@@ -15,9 +15,7 @@ from pydantic_core import PydanticUndefined
 
 
 def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
-    def try_eval_type(
-        value: Any, globalns: dict[str, Any], localns: dict[str, Any]
-    ) -> tuple[Any, bool]:
+    def try_eval_type(value: Any, globalns: dict[str, Any], localns: dict[str, Any]) -> tuple[Any, bool]:
         try:
             return eval_type_backport(value, globalns, localns), True
         except NameError:
@@ -82,6 +80,7 @@ class FuncMetadata(BaseModel):
         fn_is_async: bool,
         arguments_to_validate: dict[str, Any],
         arguments_to_pass_directly: dict[str, Any] | None,
+        context: dict[str, Any] | None = None,
     ) -> Any:
         """Call the given function with arguments validated and injected.
 
@@ -137,7 +136,10 @@ class FuncMetadata(BaseModel):
 
     @classmethod
     def func_metadata(
-        cls, func: Callable[..., Any], skip_names: Sequence[str] = ()
+        cls,
+        func: Callable[..., Any],
+        skip_names: Sequence[str] = (),
+        arg_description: dict[str, str] | None = None,
     ) -> "FuncMetadata":
         """Given a function, return metadata including a pydantic model representing its
         signature.
@@ -165,9 +167,7 @@ class FuncMetadata(BaseModel):
         globalns = getattr(func, "__globals__", {})
         for param in params.values():
             if param.name.startswith("_"):
-                raise InvalidSignature(
-                    f"Parameter {param.name} of {func.__name__} cannot start with '_'"
-                )
+                raise InvalidSignature(f"Parameter {param.name} of {func.__name__} cannot start with '_'")
             if param.name in skip_names:
                 continue
             annotation = param.annotation
@@ -176,11 +176,7 @@ class FuncMetadata(BaseModel):
             if annotation is None:
                 annotation = Annotated[
                     None,
-                    Field(
-                        default=param.default
-                        if param.default is not inspect.Parameter.empty
-                        else PydanticUndefined
-                    ),
+                    Field(default=param.default if param.default is not inspect.Parameter.empty else PydanticUndefined),
                 ]
 
             # Untyped field
@@ -194,10 +190,10 @@ class FuncMetadata(BaseModel):
 
             field_info = FieldInfo.from_annotated_attribute(
                 _get_typed_annotation(annotation, globalns),
-                param.default
-                if param.default is not inspect.Parameter.empty
-                else PydanticUndefined,
+                param.default if param.default is not inspect.Parameter.empty else PydanticUndefined,
             )
+            if not field_info.title and arg_description and arg_description.get(param.name):
+                field_info.title = arg_description.get(param.name)
             dynamic_pydantic_model_params[param.name] = (
                 field_info.annotation,
                 field_info,