universal-mcp 0.1.1__py3-none-any.whl → 0.1.2rc1__py3-none-any.whl

universal_mcp/servers/server.py

@@ -1,24 +1,45 @@
+import os
 from abc import ABC, abstractmethod
+from typing import Any
+
 import httpx
-from mcp.server.fastmcp import FastMCP
-from universal_mcp.applications import app_from_name
-from universal_mcp.exceptions import NotAuthorizedError
-from universal_mcp.integrations import ApiKeyIntegration, AgentRIntegration
-from universal_mcp.stores.store import EnvironmentStore, MemoryStore
-from universal_mcp.config import AppConfig, IntegrationConfig, StoreConfig
 from loguru import logger
-import os
-from typing import Any
-from mcp.types import TextContent
+from mcp.server.fastmcp import FastMCP
 from mcp.server.fastmcp.exceptions import ToolError
+from mcp.types import TextContent
+
+from universal_mcp.applications import app_from_slug
+from universal_mcp.config import AppConfig, IntegrationConfig, StoreConfig
+from universal_mcp.exceptions import NotAuthorizedError
+from universal_mcp.integrations import AgentRIntegration, ApiKeyIntegration
+from universal_mcp.stores import store_from_config
+
 
 class Server(FastMCP, ABC):
     """
     Server is responsible for managing the applications and the store
     It also acts as a router for the applications, and exposed to the client
     """
-    def __init__(self, name: str, description: str, **kwargs):
+
+    def __init__(
+        self, name: str, description: str, store: StoreConfig | None = None, **kwargs
+    ):
         super().__init__(name, description, **kwargs)
+        logger.info(f"Initializing server: {name} with store: {store}")
+        self.store = store_from_config(store) if store else None
+        self._setup_store(store)
+        self._load_apps()
+
+    def _setup_store(self, store_config: StoreConfig | None):
+        """
+        Setup the store for the server.
+        """
+        if store_config is None:
+            return
+        self.store = store_from_config(store_config)
+        self.add_tool(self.store.set)
+        self.add_tool(self.store.delete)
+        # self.add_tool(self.store.get)
 
     @abstractmethod
     def _load_apps(self):
@@ -36,23 +57,31 @@ class Server(FastMCP, ABC):
             else:
                 raise e
 
+
 class LocalServer(Server):
     """
     Local server for development purposes
     """
-    def __init__(self, name: str, description: str, apps_list: list[AppConfig] = [], **kwargs):
-        super().__init__(name, description=description, **kwargs)
-        self.apps_list = [AppConfig.model_validate(app) for app in apps_list]
-        self._load_apps()
-    
-    def _get_store(self, store_config: StoreConfig):
-        if store_config.type == "memory":
-            return MemoryStore()
-        elif store_config.type == "environment":
-            return EnvironmentStore()
-        return None
 
-    def _get_integration(self, integration_config: IntegrationConfig):
+    def __init__(
+        self,
+        apps_list: list[AppConfig] = None,
+        **kwargs,
+    ):
+        if not apps_list:
+            self.apps_list = []
+        else:
+            self.apps_list = apps_list
+        super().__init__(**kwargs)
+
+    def _get_store(self, store_config: StoreConfig | None):
+        logger.info(f"Getting store: {store_config}")
+        # No store override, use the one from the server
+        if store_config is None:
+            return self.store
+        return store_from_config(store_config)
+
+    def _get_integration(self, integration_config: IntegrationConfig | None):
         if not integration_config:
             return None
         if integration_config.type == "api_key":
@@ -61,17 +90,14 @@ class LocalServer(Server):
             if integration_config.credentials:
                 integration.set_credentials(integration_config.credentials)
             return integration
-        elif integration_config.type == "agentr":
-            integration = AgentRIntegration(integration_config.name, api_key=integration_config.credentials.get("api_key") if integration_config.credentials else None)
-            return integration
         return None
-    
+
     def _load_app(self, app_config: AppConfig):
         name = app_config.name
         integration = self._get_integration(app_config.integration)
-        app = app_from_name(name)(integration=integration)
+        app = app_from_slug(name)(integration=integration)
         return app
-            
+
     def _load_apps(self):
         logger.info(f"Loading apps: {self.apps_list}")
         for app_config in self.apps_list:
@@ -79,24 +105,34 @@ class LocalServer(Server):
             if app:
                 tools = app.list_tools()
                 for tool in tools:
-                    name = app.name + "_" + tool.__name__
+                    full_tool_name = app.name + "_" + tool.__name__
                     description = tool.__doc__
-                    self.add_tool(tool, name=name, description=description)
+                    should_add_tool = False
+                    if (
+                        app_config.actions is None
+                        or full_tool_name in app_config.actions
+                    ):
+                        should_add_tool = True
+                    if should_add_tool:
+                        self.add_tool(
+                            tool, name=full_tool_name, description=description
+                        )
 
-                
 
 class AgentRServer(Server):
     """
     AgentR server. Connects to the AgentR API to get the apps and tools. Only supports agentr integrations.
     """
-    def __init__(self, name: str, description: str, api_key: str | None = None, **kwargs):
-        super().__init__(name, description=description, **kwargs)
+
+    def __init__(
+        self, name: str, description: str, api_key: str | None = None, **kwargs
+    ):
         self.api_key = api_key or os.getenv("AGENTR_API_KEY")
         self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
         if not self.api_key:
             raise ValueError("API key required - get one at https://agentr.dev")
-        self._load_apps()
-    
+        super().__init__(name, description=description, **kwargs)
+
     def _load_app(self, app_config: AppConfig):
         name = app_config.name
         if app_config.integration:
@@ -104,23 +140,20 @@ class AgentRServer(Server):
             integration = AgentRIntegration(integration_name, api_key=self.api_key)
         else:
             integration = None
-        app = app_from_name(name)(integration=integration)
+        app = app_from_slug(name)(integration=integration)
         return app
-        
+
     def _list_apps_with_integrations(self):
         # TODO: get this from the API
         response = httpx.get(
-            f"{self.base_url}/api/apps/",
-            headers={
-                "X-API-KEY": self.api_key
-            }
+            f"{self.base_url}/api/apps/", headers={"X-API-KEY": self.api_key}
         )
         response.raise_for_status()
         apps = response.json()
-        
+
         logger.info(f"Apps: {apps}")
         return [AppConfig.model_validate(app) for app in apps]
-            
+
     def _load_apps(self):
         apps = self._list_apps_with_integrations()
         for app in apps:
@@ -130,4 +163,4 @@ class AgentRServer(Server):
                 for tool in tools:
                     name = app.name + "_" + tool.__name__
                     description = tool.__doc__
-                    self.add_tool(tool, name=name, description=description)
+                    self.add_tool(tool, name=name, description=description)

universal_mcp/stores/__init__.py

@@ -1,3 +1,16 @@
-from universal_mcp.stores.store import MemoryStore, EnvironmentStore, RedisStore
+from universal_mcp.config import StoreConfig
+from universal_mcp.stores.store import EnvironmentStore, KeyringStore, MemoryStore
 
-__all__ = [MemoryStore, EnvironmentStore, RedisStore]
+
+def store_from_config(store_config: StoreConfig):
+    if store_config.type == "memory":
+        return MemoryStore()
+    elif store_config.type == "environment":
+        return EnvironmentStore()
+    elif store_config.type == "keyring":
+        return KeyringStore(app_name=store_config.name)
+    else:
+        raise ValueError(f"Invalid store type: {store_config.type}")
+
+
+__all__ = [MemoryStore, EnvironmentStore, KeyringStore]

universal_mcp/stores/store.py

@@ -1,71 +1,181 @@
 import os
 from abc import ABC, abstractmethod
 
+import keyring
+from loguru import logger
+
 
 class Store(ABC):
+    """
+    Abstract base class defining the interface for credential stores.
+    All credential stores must implement get, set and delete methods.
+    """
+
     @abstractmethod
     def get(self, key: str):
+        """
+        Retrieve a value from the store by key.
+
+        Args:
+            key (str): The key to look up
+
+        Returns:
+            The stored value if found, None otherwise
+        """
         pass
 
     @abstractmethod
     def set(self, key: str, value: str):
+        """
+        Store a value in the store with the given key.
+
+        Args:
+            key (str): The key to store the value under
+            value (str): The value to store
+        """
         pass
 
     @abstractmethod
     def delete(self, key: str):
+        """
+        Delete a value from the store by key.
+
+        Args:
+            key (str): The key to delete
+        """
         pass
 
+
 class MemoryStore:
     """
     Acts as credential store for the applications.
-    Responsible for storing and retrieving credentials. 
-    Ideally should be a key value store
+    Responsible for storing and retrieving credentials.
+    Ideally should be a key value store that keeps data in memory.
     """
+
     def __init__(self):
+        """Initialize an empty dictionary to store the data."""
         self.data = {}
 
     def get(self, key: str):
+        """
+        Retrieve a value from the in-memory store by key.
+
+        Args:
+            key (str): The key to look up
+
+        Returns:
+            The stored value if found, None otherwise
+        """
         return self.data.get(key)
 
     def set(self, key: str, value: str):
+        """
+        Store a value in the in-memory store with the given key.
+
+        Args:
+            key (str): The key to store the value under
+            value (str): The value to store
+        """
         self.data[key] = value
 
     def delete(self, key: str):
+        """
+        Delete a value from the in-memory store by key.
+
+        Args:
+            key (str): The key to delete
+        """
         del self.data[key]
 
 
 class EnvironmentStore(Store):
     """
     Store that uses environment variables to store credentials.
+    Implements the Store interface using OS environment variables as the backend.
     """
+
     def __init__(self):
+        """Initialize the environment store."""
         pass
 
     def get(self, key: str):
+        """
+        Retrieve a value from environment variables by key.
+
+        Args:
+            key (str): The environment variable name to look up
+
+        Returns:
+            dict: Dictionary containing the api_key from environment variable
+        """
         return {"api_key": os.getenv(key)}
 
     def set(self, key: str, value: str):
+        """
+        Set an environment variable.
+
+        Args:
+            key (str): The environment variable name
+            value (str): The value to set
+        """
         os.environ[key] = value
 
     def delete(self, key: str):
+        """
+        Delete an environment variable.
+
+        Args:
+            key (str): The environment variable name to delete
+        """
         del os.environ[key]
 
-class RedisStore(Store):
+
+class KeyringStore(Store):
     """
-    Store that uses a redis database to store credentials.
+    Store that uses keyring to store credentials.
+    Implements the Store interface using system keyring as the backend.
     """
-    def __init__(self, host: str, port: int, db: int):
-        import redis
-        self.host = host
-        self.port = port
-        self.db = db
-        self.redis = redis.Redis(host=self.host, port=self.port, db=self.db)
+
+    def __init__(self, app_name: str = "universal_mcp"):
+        """
+        Initialize the keyring store.
+
+        Args:
+            app_name (str): The application name to use in keyring, defaults to "universal_mcp"
+        """
+        self.app_name = app_name
 
     def get(self, key: str):
-        return self.redis.get(key)
+        """
+        Retrieve a password from the system keyring.
+
+        Args:
+            key (str): The key to look up
+
+        Returns:
+            The stored password if found, None otherwise
+        """
+        logger.info(f"Getting password for {key} from keyring")
+        return keyring.get_password(self.app_name, key)
 
     def set(self, key: str, value: str):
-        self.redis.set(key, value)
+        """
+        Store a password in the system keyring.
+
+        Args:
+            key (str): The key to store the password under
+            value (str): The password to store
+        """
+        logger.info(f"Setting password for {key} in keyring")
+        keyring.set_password(self.app_name, key, value)
 
     def delete(self, key: str):
-        self.redis.delete(key)
+        """
+        Delete a password from the system keyring.
+
+        Args:
+            key (str): The key to delete
+        """
+        logger.info(f"Deleting password for {key} from keyring")
+        keyring.delete_password(self.app_name, key)

universal_mcp/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for Universal MCP."""

universal_mcp/utils/api_generator.py

@@ -0,0 +1,269 @@
+import ast
+import importlib.util
+import inspect
+import os
+import traceback
+from pathlib import Path
+
+from universal_mcp.utils.docgen import process_file
+from universal_mcp.utils.openapi import generate_api_client, load_schema
+
+README_TEMPLATE = """
+# {name} MCP Server
+
+An MCP Server for the {name} API.
+
+## Supported Integrations
+
+- AgentR
+- API Key (Coming Soon)
+- OAuth (Coming Soon)
+
+## Tools
+
+{tools}
+
+## Usage
+
+- Login to AgentR
+- Follow the quickstart guide to setup MCP Server for your client
+- Visit Apps Store and enable the {name} app
+- Restart the MCP Server
+
+### Local Development
+
+- Follow the README to test with the local MCP Server
+"""
+
+
+def echo(message: str, err: bool = False) -> None:
+    """Echo a message to the console, with optional error flag."""
+    print(message, file=os.sys.stderr if err else None)
+
+
+def validate_and_load_schema(schema_path: Path) -> dict:
+    """Validate schema file existence and load it."""
+    if not schema_path.exists():
+        echo(f"Error: Schema file {schema_path} does not exist", err=True)
+        raise FileNotFoundError(f"Schema file {schema_path} does not exist")
+
+    try:
+        return load_schema(schema_path)
+    except Exception as e:
+        echo(f"Error loading schema: {e}", err=True)
+        raise
+
+
+def write_and_verify_code(output_path: Path, code: str) -> None:
+    """Write generated code to file and verify its contents."""
+    with open(output_path, "w") as f:
+        f.write(code)
+    echo(f"Generated API client at: {output_path}")
+
+    try:
+        with open(output_path) as f:
+            file_content = f.read()
+            echo(f"Successfully wrote {len(file_content)} bytes to {output_path}")
+            ast.parse(file_content)
+            echo("Python syntax check passed")
+    except SyntaxError as e:
+        echo(f"Warning: Generated file has syntax error: {e}", err=True)
+    except Exception as e:
+        echo(f"Error verifying output file: {e}", err=True)
+
+
+async def generate_docstrings(script_path: str) -> dict[str, int]:
+    """Generate docstrings for the given script file."""
+    echo(f"Adding docstrings to {script_path}...")
+
+    if not os.path.exists(script_path):
+        echo(f"Warning: File {script_path} does not exist", err=True)
+        return {"functions_processed": 0}
+
+    try:
+        with open(script_path) as f:
+            content = f.read()
+            echo(f"Successfully read {len(content)} bytes from {script_path}")
+    except Exception as e:
+        echo(f"Error reading file for docstring generation: {e}", err=True)
+        return {"functions_processed": 0}
+
+    try:
+        processed = process_file(script_path)
+        return {"functions_processed": processed}
+    except Exception as e:
+        echo(f"Error running docstring generation: {e}", err=True)
+        traceback.print_exc()
+        return {"functions_processed": 0}
+
+
+def setup_app_directory(folder_name: str, source_file: Path) -> tuple[Path, Path]:
+    """Set up application directory structure and copy generated code."""
+    applications_dir = Path(__file__).parent.parent / "applications"
+    app_dir = applications_dir / folder_name
+    app_dir.mkdir(exist_ok=True)
+
+    init_file = app_dir / "__init__.py"
+    if not init_file.exists():
+        with open(init_file, "w") as f:
+            f.write("")
+
+    app_file = app_dir / "app.py"
+    with open(source_file) as src, open(app_file, "w") as dest:
+        app_content = src.read()
+        dest.write(app_content)
+
+    echo(f"API client installed at: {app_file}")
+    return app_dir, app_file
+
+
+def get_class_info(module: any) -> tuple[str | None, any]:
+    """Find the main class in the generated module."""
+    for name, obj in inspect.getmembers(module):
+        if inspect.isclass(obj) and obj.__module__ == "temp_module":
+            return name, obj
+    return None, None
+
+
+def collect_tools(class_obj: any, folder_name: str) -> list[tuple[str, str]]:
+    """Collect tool information from the class."""
+    tools = []
+
+    # Try to get tools from list_tools method
+    if class_obj and hasattr(class_obj, "list_tools"):
+        try:
+            instance = class_obj()
+            tool_list = instance.list_tools()
+
+            for tool in tool_list:
+                func_name = tool.__name__
+                if func_name.startswith("_") or func_name in ("__init__", "list_tools"):
+                    continue
+
+                doc = tool.__doc__ or f"Function for {func_name.replace('_', ' ')}"
+                summary = doc.split("\n\n")[0].strip()
+                tools.append((func_name, summary))
+        except Exception as e:
+            echo(f"Note: Couldn't instantiate class to get tool list: {e}")
+
+    # Fall back to inspecting class methods directly
+    if not tools and class_obj:
+        for name, method in inspect.getmembers(class_obj, inspect.isfunction):
+            if name.startswith("_") or name in ("__init__", "list_tools"):
+                continue
+
+            doc = method.__doc__ or f"Function for {name.replace('_', ' ')}"
+            summary = doc.split("\n\n")[0].strip()
+            tools.append((name, summary))
+
+    return tools
+
+
+def generate_readme(
+    app_dir: Path, folder_name: str, tools: list[tuple[str, str]]
+) -> Path:
+    """Generate README.md with API documentation."""
+    app = folder_name.replace("_", " ").title()
+
+    tools_content = f"This is automatically generated from OpenAPI schema for the {folder_name.replace('_', ' ').title()} API.\n\n"
+    tools_content += "## Supported Integrations\n\n"
+    tools_content += (
+        "This tool can be integrated with any service that supports HTTP requests.\n\n"
+    )
+    tools_content += "## Tool List\n\n"
+
+    if tools:
+        tools_content += "| Tool | Description |\n|------|-------------|\n"
+        for tool_name, tool_desc in tools:
+            tools_content += f"| {tool_name} | {tool_desc} |\n"
+        tools_content += "\n"
+    else:
+        tools_content += (
+            "No tools with documentation were found in this API client.\n\n"
+        )
+
+    readme_content = README_TEMPLATE.format(
+        name=app,
+        tools=tools_content,
+        usage="",
+    )
+    readme_file = app_dir / "README.md"
+    with open(readme_file, "w") as f:
+        f.write(readme_content)
+
+    echo(f"Documentation generated at: {readme_file}")
+    return readme_file
+
+
+async def generate_api_from_schema(
+    schema_path: Path,
+    output_path: Path | None = None,
+    add_docstrings: bool = True,
+) -> dict[str, str | None]:
+    """
+    Generate API client from OpenAPI schema with optional docstring generation.
+
+    Args:
+        schema_path: Path to the OpenAPI schema file
+        output_path: Output file path - should match the API name (e.g., 'twitter.py' for Twitter API)
+        add_docstrings: Whether to add docstrings to the generated code
+
+    Returns:
+        dict: A dictionary with information about the generated files
+    """
+    try:
+        schema = validate_and_load_schema(schema_path)
+        code = generate_api_client(schema)
+
+        if not output_path:
+            return {"code": code}
+
+        folder_name = output_path.stem
+        temp_output_path = output_path
+
+        write_and_verify_code(temp_output_path, code)
+
+        if add_docstrings:
+            result = await generate_docstrings(str(temp_output_path))
+            if result:
+                if "functions_processed" in result:
+                    echo(f"Processed {result['functions_processed']} functions")
+            else:
+                echo("Docstring generation failed", err=True)
+        else:
+            echo("Skipping docstring generation as requested")
+
+        app_dir, app_file = setup_app_directory(folder_name, temp_output_path)
+
+        try:
+            echo("Generating README.md from function information...")
+            spec = importlib.util.spec_from_file_location("temp_module", app_file)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            class_name, class_obj = get_class_info(module)
+            if not class_name:
+                class_name = folder_name.capitalize() + "App"
+
+            tools = collect_tools(class_obj, folder_name)
+            readme_file = generate_readme(app_dir, folder_name, tools)
+
+        except Exception as e:
+            echo(f"Error generating documentation: {e}", err=True)
+            readme_file = None
+
+        return {
+            "app_file": str(app_file),
+            "readme_file": str(readme_file) if readme_file else None,
+        }
+
+    finally:
+        if output_path and output_path.exists():
+            try:
+                output_path.unlink()
+                echo(f"Cleaned up temporary file: {output_path}")
+            except Exception as e:
+                echo(
+                    f"Warning: Could not remove temporary file {output_path}: {e}",
+                    err=True,
+                )