universal-mcp 0.1.24rc2__py3-none-any.whl → 0.1.24rc4__py3-none-any.whl

universal_mcp/analytics.py

@@ -67,8 +67,9 @@ class Analytics:
             properties = {
                 "version": self.get_version(),
                 "app_name": app_name,
+                "user_id": self.user_id,
             }
-            posthog.capture(self.user_id, "app_loaded", properties)
+            posthog.capture("app_loaded", properties=properties)
         except Exception as e:
             logger.error(f"Failed to track app_loaded event: {e}")
 
@@ -77,8 +78,7 @@ class Analytics:
         tool_name: str,
         app_name: str,
         status: str,
-        error: str = None,
-        user_id=None,  # Note: user_id is captured in PostHog but not used from this param
+        error: str | None = None,
     ):
         """Tracks an event when a tool is called within an application.
 
@@ -91,9 +91,6 @@ class Analytics:
             status (str): The status of the tool call (e.g., "success", "error").
             error (str, optional): The error message if the tool call failed.
                                  Defaults to None.
-            user_id (str, optional): An optional user identifier.
-                                   Note: Currently, the class uses an internally
-                                   generated user_id for PostHog events.
         """
         if not self.enabled:
             return
@@ -104,8 +101,9 @@ class Analytics:
                 "status": status,
                 "error": error,
                 "version": self.get_version(),
+                "user_id": self.user_id,
             }
-            posthog.capture(self.user_id, "tool_called", properties)
+            posthog.capture("tool_called", properties=properties)
         except Exception as e:
             logger.error(f"Failed to track tool_called event: {e}")
 

universal_mcp/applications/__init__.py

@@ -1,9 +1,3 @@
-import importlib
-import os
-import subprocess
-import sys
-from pathlib import Path
-
 from loguru import logger
 
 from universal_mcp.applications.application import (
@@ -11,92 +5,65 @@ from universal_mcp.applications.application import (
     BaseApplication,
     GraphQLApplication,
 )
+from universal_mcp.config import AppConfig
 from universal_mcp.utils.common import (
-    get_default_class_name,
-    get_default_module_path,
-    get_default_package_name,
-    get_default_repository_path,
+    load_app_from_local_file,
+    load_app_from_local_folder,
+    load_app_from_package,
+    load_app_from_remote_file,
+    load_app_from_remote_zip,
 )
 
-UNIVERSAL_MCP_HOME = Path.home() / ".universal-mcp" / "packages"
-
-if not UNIVERSAL_MCP_HOME.exists():
-    UNIVERSAL_MCP_HOME.mkdir(parents=True, exist_ok=True)
-
-# set python path to include the universal-mcp home directory
-sys.path.append(str(UNIVERSAL_MCP_HOME))
-
-
-# Name are in the format of "app-name", eg, google-calendar
-# Class name is NameApp, eg, GoogleCalendarApp
-
 app_cache: dict[str, type[BaseApplication]] = {}
 
 
-def _install_or_upgrade_package(package_name: str, repository_path: str):
+def app_from_slug(slug: str) -> type[BaseApplication]:
     """
-    Helper to install a package via pip from the universal-mcp GitHub repository.
+    Dynamically resolve and return the application class based on slug.
     """
-    uv_path = os.getenv("UV_PATH")
-    uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
-    logger.info(f"Using uv executable: {uv_executable}")
-    cmd = [
-        uv_executable,
-        "pip",
-        "install",
-        "--upgrade",
-        repository_path,
-        "--target",
-        str(UNIVERSAL_MCP_HOME),
-    ]
-    logger.debug(f"Installing package '{package_name}' with command: {' '.join(cmd)}")
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        if result.stdout:
-            logger.info(f"Command stdout: {result.stdout}")
-        if result.stderr:
-            logger.info(f"Command stderr: {result.stderr}")
-        result.check_returncode()
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Installation failed for '{package_name}': {e}")
-        if e.stdout:
-            logger.error(f"Command stdout: {e.stdout}")
-        if e.stderr:
-            logger.error(f"Command stderr: {e.stderr}")
-        raise ModuleNotFoundError(f"Installation failed for package '{package_name}'") from e
-    else:
-        logger.debug(f"Package {package_name} installed successfully")
+    return app_from_config(AppConfig(name=slug, source_type="package"))
 
 
-def app_from_slug(slug: str):
+def app_from_config(config: AppConfig) -> type[BaseApplication]:
     """
-    Dynamically resolve and return the application class for the given slug.
-    Attempts installation from GitHub if the package is not found locally.
+    Dynamically resolve and return the application class based on AppConfig.
     """
-    if slug in app_cache:
-        return app_cache[slug]
-    class_name = get_default_class_name(slug)
-    module_path = get_default_module_path(slug)
-    package_name = get_default_package_name(slug)
-    repository_path = get_default_repository_path(slug)
-    logger.debug(f"Resolving app for slug '{slug}' → module '{module_path}', class '{class_name}'")
+    if config.name in app_cache:
+        return app_cache[config.name]
+
+    app_class = None
     try:
-        _install_or_upgrade_package(package_name, repository_path)
-        module = importlib.import_module(module_path)
-        class_ = getattr(module, class_name)
-        logger.debug(f"Loaded class '{class_}' from module '{module_path}'")
-        app_cache[slug] = class_
-        return class_
-    except ModuleNotFoundError as e:
-        raise ModuleNotFoundError(f"Package '{module_path}' not found locally. Please install it first.") from e
-    except AttributeError as e:
-        raise AttributeError(f"Class '{class_name}' not found in module '{module_path}'") from e
+        match config.source_type:
+            case "package":
+                app_class = load_app_from_package(config)
+            case "local_folder":
+                app_class = load_app_from_local_folder(config)
+            case "remote_zip":
+                app_class = load_app_from_remote_zip(config)
+            case "remote_file":
+                app_class = load_app_from_remote_file(config)
+            case "local_file":
+                app_class = load_app_from_local_file(config)
+            case _:
+                raise ValueError(f"Unsupported source_type: {config.source_type}")
+
     except Exception as e:
-        raise Exception(f"Error importing module '{module_path}': {e}") from e
+        logger.error(
+            f"Failed to load application '{config.name}' from source '{config.source_type}': {e}",
+            exc_info=True,
+        )
+        raise
+
+    if not app_class:
+        raise ImportError(f"Could not load application class for '{config.name}'")
+
+    logger.debug(f"Loaded class '{app_class.__name__}' for app '{config.name}'")
+    app_cache[config.name] = app_class
+    return app_class
 
 
 __all__ = [
-    "app_from_slug",
+    "app_from_config",
     "BaseApplication",
     "APIApplication",
     "GraphQLApplication",

universal_mcp/applications/application.py

@@ -10,7 +10,7 @@ from graphql import DocumentNode
 from loguru import logger
 
 from universal_mcp.analytics import analytics
-from universal_mcp.integrations import Integration
+from universal_mcp.integrations.integration import Integration
 
 
 class BaseApplication(ABC):

universal_mcp/applications/sample/app.py

@@ -0,0 +1,245 @@
+import datetime
+
+import httpx
+
+from universal_mcp.applications.application import BaseApplication
+
+
+class SampleToolApp(BaseApplication):
+    """A sample application providing basic utility tools."""
+
+    def __init__(self):
+        """Initializes the SampleToolApp with the name 'sample_tool_app'."""
+        super().__init__(name="sample_tool_app")
+
+    def get_current_time(self):
+        """Get the current system time as a formatted string.
+
+        Returns:
+            str: The current time in the format 'YYYY-MM-DD HH:MM:SS'.
+        """
+        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def get_current_date(self):
+        """Get the current system date as a formatted string.
+
+        Returns:
+            str: The current date in the format 'YYYY-MM-DD'.
+        """
+        return datetime.datetime.now().strftime("%Y-%m-%d")
+
+    def calculate(self, expression: str):
+        """Safely evaluate a mathematical expression.
+
+        Args:
+            expression (str): The mathematical expression to evaluate.
+
+        Returns:
+            str: The result of the calculation, or an error message if evaluation fails.
+        """
+        try:
+            # Safe evaluation of mathematical expressions
+            result = eval(expression, {"__builtins__": {}}, {})  # noqa: S102
+            return f"Result: {result}"
+        except Exception as e:
+            return f"Error in calculation: {str(e)}"
+
+    def file_operations(self, operation: str, filename: str, content: str = ""):
+        """Perform file read or write operations.
+
+        Args:
+            operation (str): The operation to perform, either 'read' or 'write'.
+            filename (str): The name of the file to operate on.
+            content (str, optional): The content to write to the file (used only for 'write'). Defaults to "".
+
+        Returns:
+            str: The result of the file operation, or an error message if the operation fails.
+        """
+        try:
+            if operation == "read":
+                with open(filename) as f:
+                    return f"File content:\n{f.read()}"
+            elif operation == "write":
+                with open(filename, "w") as f:
+                    f.write(content)
+                return f"Successfully wrote to {filename}"
+            else:
+                return "Invalid operation. Use 'read' or 'write'"
+        except Exception as e:
+            return f"File operation error: {str(e)}"
+
+    def get_weather(
+        self,
+        latitude: float,
+        longitude: float,
+        current: list[str] | None = None,
+        hourly: list[str] | None = None,
+        daily: list[str] | None = None,
+        timezone: str = "auto",
+        temperature_unit: str = "celsius",
+        wind_speed_unit: str = "kmh",
+        precipitation_unit: str = "mm",
+    ) -> dict:
+        """
+        Get weather data from Open-Meteo API.
+
+        Args:
+            latitude (float): Latitude coordinate
+            longitude (float): Longitude coordinate
+            current (List[str], optional): Current weather parameters to fetch
+            hourly (List[str], optional): Hourly weather parameters to fetch
+            daily (List[str], optional): Daily weather parameters to fetch
+            timezone (str): Timezone (default: "auto")
+            temperature_unit (str): Temperature unit - "celsius" or "fahrenheit"
+            wind_speed_unit (str): Wind speed unit - "kmh", "ms", "mph", "kn"
+            precipitation_unit (str): Precipitation unit - "mm" or "inch"
+
+        Returns:
+            Dict: Weather data from the API
+
+        Raises:
+            httpx.RequestError: If API request fails
+            ValueError: If coordinates are invalid
+        """
+        # Validate coordinates
+        if not (-90 <= latitude <= 90):
+            raise ValueError("Latitude must be between -90 and 90")
+        if not (-180 <= longitude <= 180):
+            raise ValueError("Longitude must be between -180 and 180")
+
+        # Base URL
+        base_url = "https://api.open-meteo.com/v1/forecast"
+
+        # Default parameters if none provided
+        if current is None:
+            current = ["temperature_2m", "relative_humidity_2m", "weather_code", "wind_speed_10m", "wind_direction_10m"]
+
+        if daily is None:
+            daily = ["temperature_2m_max", "temperature_2m_min", "weather_code", "precipitation_sum"]
+
+        # Build parameters
+        params = {
+            "latitude": latitude,
+            "longitude": longitude,
+            "timezone": timezone,
+            "temperature_unit": temperature_unit,
+            "wind_speed_unit": wind_speed_unit,
+            "precipitation_unit": precipitation_unit,
+        }
+
+        # Add weather parameters
+        if current:
+            params["current"] = ",".join(current)
+        if hourly:
+            params["hourly"] = ",".join(hourly)
+        if daily:
+            params["daily"] = ",".join(daily)
+
+        try:
+            # Make API request
+            with httpx.Client(timeout=10) as client:
+                response = client.get(base_url, params=params)
+                response.raise_for_status()
+                return response.json()
+
+        except httpx.TimeoutException as e:
+            raise httpx.RequestError("Request timed out") from e
+        except httpx.ConnectError as e:
+            raise httpx.RequestError("Connection error") from e
+        except httpx.HTTPStatusError as e:
+            raise httpx.RequestError(f"HTTP error: {e}") from e
+        except httpx.RequestError as e:
+            raise httpx.RequestError(f"Request failed: {e}") from e
+
+    def get_simple_weather(self, latitude: float, longitude: float) -> dict:
+        """
+        Get simplified current weather data.
+
+        Args:
+            latitude (float): Latitude coordinate
+            longitude (float): Longitude coordinate
+
+        Returns:
+            Dict: Simplified weather data with current conditions
+        """
+
+        try:
+            weather_data = self.get_weather(
+                latitude=latitude,
+                longitude=longitude,
+                current=[
+                    "temperature_2m",
+                    "relative_humidity_2m",
+                    "weather_code",
+                    "wind_speed_10m",
+                    "wind_direction_10m",
+                    "precipitation",
+                ],
+            )
+
+            # Weather code descriptions (WMO Weather interpretation codes)
+            weather_codes = {
+                0: "Clear sky",
+                1: "Mainly clear",
+                2: "Partly cloudy",
+                3: "Overcast",
+                45: "Fog",
+                48: "Depositing rime fog",
+                51: "Light drizzle",
+                53: "Moderate drizzle",
+                55: "Dense drizzle",
+                61: "Slight rain",
+                63: "Moderate rain",
+                65: "Heavy rain",
+                71: "Slight snow fall",
+                73: "Moderate snow fall",
+                75: "Heavy snow fall",
+                80: "Slight rain showers",
+                81: "Moderate rain showers",
+                82: "Violent rain showers",
+                95: "Thunderstorm",
+                96: "Thunderstorm with slight hail",
+                99: "Thunderstorm with heavy hail",
+            }
+
+            current = weather_data.get("current", {})
+            weather_code = current.get("weather_code", 0)
+
+            simplified = {
+                "location": {
+                    "latitude": weather_data.get("latitude"),
+                    "longitude": weather_data.get("longitude"),
+                    "timezone": weather_data.get("timezone"),
+                },
+                "current": {
+                    "time": current.get("time"),
+                    "temperature": current.get("temperature_2m"),
+                    "temperature_unit": weather_data.get("current_units", {}).get("temperature_2m", "°C"),
+                    "humidity": current.get("relative_humidity_2m"),
+                    "weather_description": weather_codes.get(weather_code, "Unknown"),
+                    "weather_code": weather_code,
+                    "wind_speed": current.get("wind_speed_10m"),
+                    "wind_speed_unit": weather_data.get("current_units", {}).get("wind_speed_10m", "km/h"),
+                    "wind_direction": current.get("wind_direction_10m"),
+                    "precipitation": current.get("precipitation", 0),
+                },
+            }
+
+            return simplified
+
+        except Exception as e:
+            return {"error": str(e)}
+
+    def list_tools(self):
+        """List all available tool methods in this application.
+
+        Returns:
+            list: A list of callable tool methods.
+        """
+        return [
+            self.get_current_time,
+            self.get_current_date,
+            self.calculate,
+            self.file_operations,
+            self.get_simple_weather,
+        ]

universal_mcp/cli.py

@@ -4,7 +4,7 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 
-from universal_mcp.client.cli import app as client_app
+from universal_mcp.agents.cli import app as client_app
 from universal_mcp.utils.installation import (
     get_supported_apps,
     install_app,
@@ -24,13 +24,20 @@ def run(
     config_path: Path | None = typer.Option(None, "--config", "-c", help="Path to the config file"),
 ):
     """Run the MCP server"""
+    from universal_mcp.agentr.server import AgentrServer
     from universal_mcp.config import ServerConfig
     from universal_mcp.logger import setup_logger
-    from universal_mcp.servers import server_from_config
+    from universal_mcp.servers import LocalServer
 
     config = ServerConfig.model_validate_json(config_path.read_text()) if config_path else ServerConfig()
     setup_logger(level=config.log_level)
-    server = server_from_config(config)
+
+    if config.type == "agentr":
+        server = AgentrServer(config=config, api_key=config.api_key)
+    elif config.type == "local":
+        server = LocalServer(config=config)
+    else:
+        raise ValueError(f"Unsupported server type: {config.type}")
     server.run(transport=config.transport)
 
 

universal_mcp/config.py

@@ -23,7 +23,7 @@ class StoreConfig(BaseModel):
     )
     path: Path | None = Field(
         default=None,
-        description="Filesystem path for store types that require it (e.g., a future 'file' store type). Currently not used by memory, environment, or keyring.",
+        description="Filesystem path for store types that require it (e.g., a future 'file' store type)",
     )
 
 
@@ -73,6 +73,21 @@ class AppConfig(BaseModel):
         description="A list of specific actions or tools provided by this application that should be exposed. If None or empty, all tools from the application might be exposed by default, depending on the application's implementation.",
     )
 
+    source_type: Literal["package", "local_folder", "remote_zip", "remote_file", "local_file"] = Field(
+        default="package",
+        description="The source of the application. 'package' (default) installs from a repository, 'local_folder' loads from a local path, 'remote_zip' downloads and extracts a project zip, 'remote_file' downloads a single Python file from a URL, 'local_file' loads a single Python file from the local filesystem.",
+    )
+    source_path: str | None = Field(
+        default=None,
+        description="The path or URL for 'local_folder', 'remote_zip', 'remote_file', or 'local_file' source types.",
+    )
+
+    @model_validator(mode="after")
+    def check_path_for_non_package_sources(self) -> Self:
+        if self.source_type in ["local_folder", "remote_zip", "remote_file", "local_file"] and not self.source_path:
+            raise ValueError(f"'source_path' is required for source_type '{self.source_type}'")
+        return self
+
 
 class ServerConfig(BaseSettings):
     """Core configuration settings for the Universal MCP server.
@@ -89,14 +104,13 @@ class ServerConfig(BaseSettings):
         case_sensitive=True,
         extra="allow",
     )
-
     name: str = Field(default="Universal MCP", description="Name of the MCP server")
     description: str = Field(
         default="Universal MCP", description="A brief description of this MCP server's purpose or deployment."
     )
     type: Literal["local", "agentr", "other"] = Field(
         default="agentr",
-        description="Deployment type of the server. 'local' runs apps defined in 'apps' list; 'agentr' dynamically loads apps from the AgentR platform.",
+        description="Source of apps to load. Local apps are defined in 'apps' list; AgentR apps are dynamically loaded from the AgentR platform.",
     )
     transport: Literal["stdio", "sse", "streamable-http"] = Field(
         default="stdio",
@@ -148,7 +162,7 @@ class ServerConfig(BaseSettings):
         return v
 
     @classmethod
-    def load_json_config(cls, path: str = "local_config.json") -> Self:
+    def load_json_config(cls, path: str = "server_config.json") -> Self:
         """Loads server configuration from a JSON file.
 
         Args:
@@ -221,16 +235,28 @@ class ClientConfig(BaseSettings):
 
     mcpServers: dict[str, ClientTransportConfig] = Field(
         ...,
-        description="A dictionary where keys are descriptive names for MCP server connections and values are `ClientTransportConfig` objects defining how to connect to each server.",
+        description="Dictionary of MCP server connections. Keys are descriptive names for the server, values are `ClientTransportConfig` objects defining how to connect to each server.",
+    )
+    apps: list[AppConfig] = Field(
+        default=[],
+        description="List of application configurations to load",
+    )
+    store: StoreConfig | None = Field(
+        default=None,
+        description="Default credential store configuration for applications that do not define their own specific store.",
+    )
+    model: str = Field(
+        default="openrouter/auto",
+        description="The model to use for the LLM.",
     )
 
     @classmethod
-    def load_json_config(cls, path: str = "servers.json") -> Self:
+    def load_json_config(cls, path: Path) -> Self:
         """Loads client configuration from a JSON file.
 
         Args:
             path (str, optional): The path to the JSON configuration file.
-                Defaults to "servers.json".
+                Defaults to "client_config.json".
 
         Returns:
             ClientConfig: An instance of ClientConfig populated with data

universal_mcp/exceptions.py

@@ -26,6 +26,10 @@ class ToolError(Exception):
     pass
 
 
+class ToolNotFoundError(Exception):
+    """Raised when a tool is not found"""
+
+
 class InvalidSignature(Exception):
     """Raised when a cryptographic signature verification fails.
 

universal_mcp/integrations/__init__.py

@@ -1,26 +1,11 @@
-from universal_mcp.config import IntegrationConfig
 from universal_mcp.integrations.integration import (
-    AgentRIntegration,
     ApiKeyIntegration,
     Integration,
     OAuthIntegration,
 )
-from universal_mcp.stores.store import BaseStore
-
-
-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":
-        return AgentRIntegration(config.name, **kwargs)
-    else:
-        raise ValueError(f"Unsupported integration type: {config.type}")
-
 
 __all__ = [
-    "AgentRIntegration",
     "ApiKeyIntegration",
     "Integration",
     "OAuthIntegration",
-    "integration_from_config",
 ]