universal-mcp 0.1.0__py3-none-any.whl

universal_mcp/integrations/agentr.py

@@ -0,0 +1,87 @@
+from universal_mcp.integrations.integration import Integration
+import os
+import httpx
+from loguru import logger
+from universal_mcp.exceptions import NotAuthorizedError
+
+class AgentRIntegration(Integration):
+    """Integration class for AgentR API authentication and authorization.
+    
+    This class handles API key authentication and OAuth authorization flow for AgentR services.
+    
+    Args:
+        name (str): Name of the integration
+        api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var
+        **kwargs: Additional keyword arguments passed to parent Integration class
+        
+    Raises:
+        ValueError: If no API key is provided or found in environment variables
+    """
+    def __init__(self, name: str, api_key: str = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if not self.api_key:
+            logger.error("API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable.")
+            raise ValueError("AgentR API key required - get one at https://agentr.dev")
+        self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+    
+    def set_credentials(self, credentials: dict| None = None):
+        """Set credentials for the integration.
+        
+        This method is not implemented for AgentR integration. Instead it redirects to the authorize flow.
+        
+        Args:
+            credentials (dict | None, optional): Credentials dict (not used). Defaults to None.
+            
+        Returns:
+            str: Authorization URL from authorize() method
+        """
+        return self.authorize()
+        # raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
+
+    def get_credentials(self):
+        """Get credentials for the integration from the AgentR API.
+        
+        Makes API request to retrieve stored credentials for this integration.
+        
+        Returns:
+            dict: Credentials data from API response
+            
+        Raises:
+            NotAuthorizedError: If credentials are not found (404 response)
+            HTTPError: For other API errors
+        """
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/credentials/",
+            headers={
+                "accept": "application/json",
+                "X-API-KEY": self.api_key
+            }
+        )
+        if response.status_code == 404:
+            action = self.authorize()
+            raise NotAuthorizedError(action)
+        response.raise_for_status()
+        data = response.json()
+        return data
+
+    def authorize(self):
+        """Get authorization URL for the integration.
+        
+        Makes API request to get OAuth authorization URL.
+        
+        Returns:
+            str: Message containing authorization URL
+            
+        Raises:
+            HTTPError: If API request fails
+        """
+        response = httpx.get(
+            f"{self.base_url}/api/{self.name}/authorize/",
+            headers={
+                "X-API-KEY": self.api_key
+            }
+        )
+        response.raise_for_status()
+        url = response.json()
+        return f"Please authorize the application by clicking the link {url}"

universal_mcp/integrations/integration.py

@@ -0,0 +1,141 @@
+from abc import ABC, abstractmethod
+from universal_mcp.stores.store import Store
+import httpx
+
+class Integration(ABC):
+    """Abstract base class for handling application integrations and authentication.
+    
+    This class defines the interface for different types of integrations that handle
+    authentication and authorization with external services.
+    
+    Args:
+        name: The name identifier for this integration
+        store: Optional Store instance for persisting credentials and other data
+    
+    Attributes:
+        name: The name identifier for this integration
+        store: Store instance for persisting credentials and other data
+    """
+    def __init__(self, name: str, store: Store = None):
+        self.name = name
+        self.store = store
+
+    @abstractmethod
+    def authorize(self):
+        """Authorize the integration.
+        
+        Returns:
+            str: Authorization URL.
+        """
+        pass
+    
+    @abstractmethod
+    def get_credentials(self):
+        """Get credentials for the integration.
+        
+        Returns:
+            dict: Credentials for the integration.
+        
+        Raises:
+            NotAuthorizedError: If credentials are not found.
+        """
+        pass
+
+    @abstractmethod
+    def set_credentials(self, credentials: dict):
+        """Set credentials for the integration.
+        
+        Args:
+            credentials: Credentials for the integration.
+        """
+        pass
+
+
+
+class ApiKeyIntegration(Integration):
+    def __init__(self, name: str, store: Store = None, **kwargs):
+        super().__init__(name, store, **kwargs)
+
+    def get_credentials(self):
+        credentials = self.store.get(self.name)
+        return credentials
+
+    def set_credentials(self, credentials: dict):
+        self.store.set(self.name, credentials)
+
+    def authorize(self):
+        return {"text": "Please configure the API Key for {self.name}"}
+    
+
+class OAuthIntegration(Integration):
+    def __init__(self, name: str, store: Store = None, client_id: str = None, client_secret: str = None, auth_url: str = None, token_url: str = None, scope: str = None, **kwargs):
+        super().__init__(name, store, **kwargs)
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.auth_url = auth_url
+        self.token_url = token_url
+        self.scope = scope
+
+    def get_credentials(self):
+        credentials = self.store.get(self.name)
+        if not credentials:
+            return None
+        return credentials
+    
+    def set_credentials(self, credentials: dict):
+        if not credentials or not isinstance(credentials, dict):
+            raise ValueError("Invalid credentials format")
+        if 'access_token' not in credentials:
+            raise ValueError("Credentials must contain access_token")
+        self.store.set(self.name, credentials)
+
+    def authorize(self):
+        if not all([self.client_id, self.client_secret, self.auth_url, self.token_url]):
+            raise ValueError("Missing required OAuth configuration")
+        
+        auth_params = {
+            'client_id': self.client_id,
+            'response_type': 'code',
+            'scope': self.scope,
+        }
+        
+        return {
+            "url": self.auth_url,
+            "params": auth_params,
+            "client_secret": self.client_secret,
+            "token_url": self.token_url
+        }
+    
+    def handle_callback(self, code: str):
+        if not all([self.client_id, self.client_secret, self.token_url]):
+            raise ValueError("Missing required OAuth configuration")
+        
+        token_params = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'code': code,
+            'grant_type': 'authorization_code'
+        }
+        
+        response = httpx.post(self.token_url, data=token_params)
+        response.raise_for_status()
+        credentials = response.json()
+        self.store.set(self.name, credentials)
+        return credentials
+
+    def refresh_token(self):
+        if not all([self.client_id, self.client_secret, self.token_url]):
+            raise ValueError("Missing required OAuth configuration")
+        
+        token_params = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'grant_type': 'refresh_token',
+            'refresh_token': self.credentials['refresh_token']
+        }
+        
+        response = httpx.post(self.token_url, data=token_params)
+        response.raise_for_status()
+        credentials = response.json()
+        self.store.set(self.name, credentials)
+        return credentials

universal_mcp/servers/__init__.py

@@ -0,0 +1,3 @@
+from universal_mcp.servers.server import AgentRServer, LocalServer
+
+__all__ = [AgentRServer, LocalServer]

universal_mcp/servers/server.py

@@ -0,0 +1,134 @@
+from abc import ABC, abstractmethod
+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.exceptions import ToolError
+
+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):
+        super().__init__(name, description, **kwargs)
+
+    @abstractmethod
+    def _load_apps(self):
+        pass
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]):
+        """Call a tool by name with arguments."""
+        try:
+            result = await super().call_tool(name, arguments)
+            return result
+        except ToolError as e:
+            raised_error = e.__cause__
+            if isinstance(raised_error, NotAuthorizedError):
+                return [TextContent(type="text", text=raised_error.message)]
+            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):
+        if not integration_config:
+            return None
+        if integration_config.type == "api_key":
+            store = self._get_store(integration_config.store)
+            integration = ApiKeyIntegration(integration_config.name, store=store)
+            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)
+        return app
+            
+    def _load_apps(self):
+        logger.info(f"Loading apps: {self.apps_list}")
+        for app_config in self.apps_list:
+            app = self._load_app(app_config)
+            if app:
+                tools = app.list_tools()
+                for tool in tools:
+                    name = app.name + "_" + tool.__name__
+                    description = tool.__doc__
+                    self.add_tool(tool, name=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)
+        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()
+    
+    def _load_app(self, app_config: AppConfig):
+        name = app_config.name
+        if app_config.integration:
+            integration_name = app_config.integration.name
+            integration = AgentRIntegration(integration_name, api_key=self.api_key)
+        else:
+            integration = None
+        app = app_from_name(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
+            }
+        )
+        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:
+            app = self._load_app(app)
+            if app:
+                tools = app.list_tools()
+                for tool in tools:
+                    name = app.name + "_" + tool.__name__
+                    description = tool.__doc__
+                    self.add_tool(tool, name=name, description=description)

universal_mcp/stores/__init__.py

@@ -0,0 +1,3 @@
+from universal_mcp.stores.store import MemoryStore, EnvironmentStore, RedisStore
+
+__all__ = [MemoryStore, EnvironmentStore, RedisStore]

universal_mcp/stores/store.py

@@ -0,0 +1,71 @@
+import os
+from abc import ABC, abstractmethod
+
+
+class Store(ABC):
+    @abstractmethod
+    def get(self, key: str):
+        pass
+
+    @abstractmethod
+    def set(self, key: str, value: str):
+        pass
+
+    @abstractmethod
+    def delete(self, key: str):
+        pass
+
+class MemoryStore:
+    """
+    Acts as credential store for the applications.
+    Responsible for storing and retrieving credentials. 
+    Ideally should be a key value store
+    """
+    def __init__(self):
+        self.data = {}
+
+    def get(self, key: str):
+        return self.data.get(key)
+
+    def set(self, key: str, value: str):
+        self.data[key] = value
+
+    def delete(self, key: str):
+        del self.data[key]
+
+
+class EnvironmentStore(Store):
+    """
+    Store that uses environment variables to store credentials.
+    """
+    def __init__(self):
+        pass
+
+    def get(self, key: str):
+        return {"api_key": os.getenv(key)}
+
+    def set(self, key: str, value: str):
+        os.environ[key] = value
+
+    def delete(self, key: str):
+        del os.environ[key]
+
+class RedisStore(Store):
+    """
+    Store that uses a redis database to store credentials.
+    """
+    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 get(self, key: str):
+        return self.redis.get(key)
+
+    def set(self, key: str, value: str):
+        self.redis.set(key, value)
+
+    def delete(self, key: str):
+        self.redis.delete(key)