universal-mcp 0.1.2rc1__py3-none-any.whl → 0.1.3rc1__py3-none-any.whl

universal_mcp/applications/notion/app.py

@@ -0,0 +1,407 @@
+from typing import Any
+
+from universal_mcp.applications import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class NotionApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        """
+        Initializes a new instance of the Notion API app with a specified integration and additional parameters.
+        
+        Args:
+            integration: Optional; an Integration object containing credentials for authenticating with the Notion API. Defaults to None.
+            kwargs: Additional keyword arguments that are passed to the parent class initializer.
+        
+        Returns:
+            None
+        """
+        super().__init__(name='notion', integration=integration, **kwargs)
+        self.base_url = "https://api.notion.com"
+
+    def _get_headers(self):
+        if not self.integration:
+            raise ValueError("Integration not configured for NotionApp")
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/json",
+            "Notion-Version": "2022-06-28",
+        }     
+
+    def retrieve_a_user(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Retrieves user details from the server using the specified user ID.
+        
+        Args:
+            self: Instance of the class containing the method.
+            id: The unique identifier of the user to retrieve.
+            request_body: Optional request body data, provided when needed. Default is None.
+        
+        Returns:
+            A dictionary containing user details, as retrieved from the server response.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/users/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def list_all_users(self, ) -> dict[str, Any]:
+        """
+        Fetches a list of all users from the API endpoint and returns the data as a dictionary.
+        
+        Args:
+            None: This method does not take any parameters.
+        
+        Returns:
+            A dictionary containing the list of users retrieved from the API. The dictionary keys are strings, and the values can be of any type.
+        """
+        url = f"{self.base_url}/v1/users"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_your_token_sbot_user(self, ) -> dict[str, Any]:
+        """
+        Retrieves the authentication token for the current user from the SBOT service.
+        
+        Args:
+            self: Instance of the class containing configuration such as 'base_url' and the '_get' method.
+        
+        Returns:
+            A dictionary containing the JSON response of the current user's token information.
+        """
+        url = f"{self.base_url}/v1/users/me"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_a_database(self, id) -> dict[str, Any]:
+        """
+        Retrieves database details from a specified endpoint using the provided database ID.
+        
+        Args:
+            id: A unique identifier for the database to be retrieved. Must be a non-null value.
+        
+        Returns:
+            A dictionary containing the details of the requested database.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def update_a_database(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates a database entry with the given ID using a PATCH request.
+        
+        Args:
+            self: The instance of the class to which the method belongs.
+            id: The unique identifier of the database entry to be updated.
+            request_body: An optional dictionary containing the data to update the database entry with. Defaults to None.
+        
+        Returns:
+            A dictionary representing the JSON response from the server after the update operation.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}"
+        query_params = {}
+        response = self._patch(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def query_a_database(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Executes a query on a specified database using an identifier and an optional request body.
+        
+        Args:
+            id: The unique identifier of the database to query.
+            request_body: Optional JSON-compatible dictionary representing the body of the query request; if None, no additional query data is sent.
+        
+        Returns:
+            A dictionary containing the response data from the database query as parsed from JSON.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/databases/{id}/query"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def create_a_database(self, request_body=None) -> dict[str, Any]:
+        """
+        Creates a new database on the server using the specified request body.
+        
+        Args:
+            request_body: A dictionary containing the data to be sent in the request body. Defaults to None if not provided.
+        
+        Returns:
+            A dictionary containing the server's JSON response from the database creation request.
+        """
+        url = f"{self.base_url}/v1/databases/"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def create_a_page(self, request_body=None) -> dict[str, Any]:
+        """
+        Creates a new page by sending a POST request to the specified endpoint.
+        
+        Args:
+            request_body: Optional; A dictionary containing the data to be sent in the body of the POST request. Defaults to None.
+        
+        Returns:
+            A dictionary representing the JSON response from the server, containing the details of the newly created page.
+        """
+        url = f"{self.base_url}/v1/pages/"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_a_page(self, id) -> dict[str, Any]:
+        """
+        Retrieves a page by its unique identifier from a remote server.
+        
+        Args:
+            id: The unique identifier of the page to retrieve.
+        
+        Returns:
+            A dictionary containing the JSON response from the server, which represents the page data.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/pages/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def update_page_properties(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates the properties of a page identified by its ID using the provided request body.
+        
+        Args:
+            id: The unique identifier of the page whose properties are to be updated. Must not be None.
+            request_body: An optional dictionary representing the request payload containing the properties to be updated. Defaults to None.
+        
+        Returns:
+            A dictionary containing the updated page properties as returned by the server after the update.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/pages/{id}"
+        query_params = {}
+        response = self._patch(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_a_page_property_item(self, page_id, property_id) -> dict[str, Any]:
+        """
+        Retrieves the property item of a page using specified page and property identifiers.
+        
+        Args:
+            page_id: The unique identifier of the page from which the property item is to be retrieved.
+            property_id: The unique identifier of the property associated with the specified page.
+        
+        Returns:
+            A dictionary representing the JSON response with details of the property item.
+        """
+        if page_id is None:
+            raise ValueError("Missing required parameter 'page_id'")
+        if property_id is None:
+            raise ValueError("Missing required parameter 'property_id'")
+        url = f"{self.base_url}/v1/pages/{page_id}/properties/{property_id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
+        """
+        Retrieves the children of a specified block using its unique identifier.
+        
+        Args:
+            id: The unique identifier of the block whose children are to be retrieved.
+            page_size: Optional; The maximum number of children to return per page in the response, if specified.
+        
+        Returns:
+            A dictionary containing the data representing the children of the specified block.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}/children"
+        query_params = {k: v for k, v in [('page_size', page_size)] if v is not None}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def append_block_children(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Appends child elements to a block identified by its ID and returns the updated block data.
+        
+        Args:
+            self: Instance of the class containing this method.
+            id: The identifier of the block to which children will be appended. It must not be None.
+            request_body: Optional dictionary containing the data of the child elements to be appended to the block.
+        
+        Returns:
+            A dictionary representing the updated block data after appending the child elements.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}/children"
+        query_params = {}
+        response = self._patch(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_a_block(self, id) -> dict[str, Any]:
+        """
+        Retrieves a block of data from a given API endpoint using the specified block ID.
+        
+        Args:
+            id: The unique identifier for the block to be retrieved. It must be a non-None value, otherwise a ValueError will be raised.
+        
+        Returns:
+            A dictionary containing the JSON response from the API, representing the block data corresponding to the provided ID.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def delete_a_block(self, id) -> dict[str, Any]:
+        """
+        Deletes a block by its unique identifier and returns the server's response.
+        
+        Args:
+            id: The unique identifier of the block to be deleted. Must not be None.
+        
+        Returns:
+            A dictionary containing the response data from the server after attempting to delete the block.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._delete(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def update_a_block(self, id, request_body=None) -> dict[str, Any]:
+        """
+        Updates a block by sending a PATCH request to the specified endpoint.
+        
+        Args:
+            id: The unique identifier for the block that is to be updated.
+            request_body: Optional; A dictionary containing the data to update the block with. Defaults to None.
+        
+        Returns:
+            A dictionary containing the JSON response from the server after updating the block.
+        """
+        if id is None:
+            raise ValueError("Missing required parameter 'id'")
+        url = f"{self.base_url}/v1/blocks/{id}"
+        query_params = {}
+        response = self._patch(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def search(self, request_body=None) -> dict[str, Any]:
+        """
+        Executes a search query using the specified request body and returns the results.
+        
+        Args:
+            request_body: An optional dictionary containing the data to be sent in the search request.
+        
+        Returns:
+            A dictionary containing the JSON-decoded response from the search operation.
+        """
+        url = f"{self.base_url}/v1/search"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def retrieve_comments(self, block_id=None, page_size=None, request_body=None) -> dict[str, Any]:
+        """
+        Fetches comments from a remote server for a specified block, with optional pagination.
+        
+        Args:
+            block_id: Optional; Identifies the block whose comments should be retrieved. If None, retrieves comments without filtering by block.
+            page_size: Optional; Specifies the number of comments to retrieve per page for pagination. If None, the server's default page size is used.
+            request_body: Unused placeholder for future extensibility; this function currently does not utilize this parameter.
+        
+        Returns:
+            A dictionary containing the response data from the server, parsed from JSON, with keys and values representing comment-related information.
+        """
+        url = f"{self.base_url}/v1/comments"
+        query_params = {k: v for k, v in [('block_id', block_id), ('page_size', page_size)] if v is not None}
+        response = self._get(url, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def add_comment_to_page(self, request_body=None) -> dict[str, Any]:
+        """
+        Adds a comment to a page by sending a POST request with the provided request body.
+        
+        Args:
+            request_body: Optional; A dictionary containing the data for the comment to be added. Defaults to None.
+        
+        Returns:
+            A dictionary representing the JSON response from the server, which includes details of the newly added comment.
+        """
+        url = f"{self.base_url}/v1/comments"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def list_tools(self):
+        """
+        Returns a list of functions related to user and database operations.
+        
+        Args:
+            self: The instance of the class to which the function belongs.
+        
+        Returns:
+            A list of method references that pertain to various operations such as user retrieval, database operations, and page/block management.
+        """
+        return [
+            self.retrieve_a_user,
+            self.list_all_users,
+            self.retrieve_your_token_sbot_user,
+            self.retrieve_a_database,
+            self.update_a_database,
+            self.query_a_database,
+            self.create_a_database,
+            self.create_a_page,
+            self.retrieve_a_page,
+            self.update_page_properties,
+            self.retrieve_a_page_property_item,
+            self.retrieve_block_children,
+            self.append_block_children,
+            self.retrieve_a_block,
+            self.delete_a_block,
+            self.update_a_block,
+            self.search,
+            self.retrieve_comments,
+            self.add_comment_to_page
+        ]

universal_mcp/applications/perplexity/app.py

@@ -0,0 +1,79 @@
+from typing import Any, Literal
+
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class PerplexityApp(APIApplication):
+    def __init__(self, integration: Integration | None = None) -> None:
+        super().__init__(name="perplexity", integration=integration)
+        self.api_key: str | None = None
+        self.base_url = "https://api.perplexity.ai"
+
+    def _set_api_key(self):
+        if self.api_key:
+            return
+
+        if not self.integration:
+            raise ValueError("Integration is None. Cannot retrieve Perplexity API Key.")
+
+        credentials = self.integration.get_credentials()
+        if not credentials:
+             raise ValueError(
+                f"Failed to retrieve Perplexity API Key using integration '{self.integration.name}'. "
+             )
+        
+        if not isinstance(credentials, str) or not credentials.strip():
+             raise ValueError(
+                f"Invalid credential format received for Perplexity API Key via integration '{self.integration.name}'. "
+            )
+        self.api_key = credentials
+
+    def _get_headers(self) -> dict[str, str]:
+        self._set_api_key()
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    def chat(self, query: str, model: Literal["r1-1776","sonar","sonar-pro","sonar-reasoning","sonar-reasoning-pro", "sonar-deep-research"] = "sonar" , temperature: float = 1, system_prompt: str = "Be precise and concise.") -> dict[str, Any] | str:
+        """
+        Sends a query to a Perplexity Sonar online model and returns the response.
+
+        This uses the chat completions endpoint, suitable for conversational queries
+        and leveraging Perplexity's online capabilities.
+
+        Args:
+            query: The user's query or message.
+            model: The specific Perplexity model to use (e.g., "r1-1776","sonar","sonar-pro","sonar-reasoning","sonar-reasoning-pro", "sonar-deep-research").Defaults to 'sonar'.
+            temperature: Sampling temperature for the response generation (e.g., 0.7).
+            system_prompt: An optional system message to guide the model's behavior.
+
+        Returns:
+            A dictionary containing 'content' (str) and 'citations' (list) on success, or a string containing an error message on failure.
+        """
+        endpoint = f"{self.base_url}/chat/completions"
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": query})
+
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            # "max_tokens": 512,
+        }
+
+        data = self._post(endpoint, data=payload)
+        response = data.json()
+        content = response['choices'][0]['message']['content']
+        citations = response.get('citations', [])
+        return {"content": content, "citations": citations}
+
+    def list_tools(self):
+        return [
+            self.chat,
+        ]

universal_mcp/cli.py

@@ -3,6 +3,8 @@ import os
 from pathlib import Path
 
 import typer
+from rich import print as rprint
+from rich.panel import Panel
 
 from universal_mcp.utils.installation import (
     get_supported_apps,
@@ -29,7 +31,7 @@ def generate(
     """Generate API client from OpenAPI schema with optional docstring generation.
 
     The output filename should match the name of the API in the schema (e.g., 'twitter.py' for Twitter API).
-    This name will be used for the folder in applications/ and as a prefix for function names.
+    This name will be used for the folder in applications/.
     """
     # Import here to avoid circular imports
     from universal_mcp.utils.api_generator import generate_api_from_schema
@@ -66,7 +68,7 @@ def generate(
 def docgen(
     file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
     model: str = typer.Option(
-        "anthropic/claude-3-sonnet-20240229",
+        "anthropic/claude-3-5-sonnet-20241022",
         "--model",
         "-m",
         help="Model to use for generating docstrings",
@@ -97,9 +99,6 @@ def docgen(
         typer.echo(f"Successfully processed {processed} functions")
     except Exception as e:
         typer.echo(f"Error: {e}", err=True)
-        import traceback
-
-        traceback.print_exc()
         raise typer.Exit(1) from e
 
 
@@ -111,8 +110,11 @@ def run(
 ):
     """Run the MCP server"""
     from universal_mcp.config import ServerConfig
+    from universal_mcp.logger import setup_logger
     from universal_mcp.servers import server_from_config
 
+    setup_logger()
+
     if config_path:
         config = ServerConfig.model_validate_json(config_path.read_text())
     else:
@@ -135,18 +137,23 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
         raise typer.Exit(1)
 
     # Print instructions before asking for API key
-    typer.echo(
-        "╭─ Instruction ─────────────────────────────────────────────────────────────────╮"
-    )
-    typer.echo(
-        "│ API key is required. Visit https://agentr.dev to create an API key.           │"
-    )
-    typer.echo(
-        "╰───────────────────────────────────────────────────────────────────────────────╯"
+
+    rprint(
+        Panel(
+            "API key is required. Visit [link]https://agentr.dev[/link] to create an API key.",
+            title="Instruction",
+            border_style="blue",
+            padding=(1, 2),
+        )
     )
 
     # Prompt for API key
-    api_key = typer.prompt("Enter your AgentR API key", hide_input=True)
+    api_key = typer.prompt(
+        "Enter your AgentR API key",
+        hide_input=False,
+        show_default=False,
+        type=str,
+    )
     try:
         if app_name == "claude":
             typer.echo(f"Installing mcp server for: {app_name}")

universal_mcp/integrations/integration.py

@@ -7,6 +7,13 @@ from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.stores.store import Store
 
 
+def sanitize_api_key_name(name: str) -> str:
+    suffix = "_API_KEY" 
+    if name.endswith(suffix) or name.endswith(suffix.lower()):
+        return name.upper()
+    else:
+        return f"{name.upper()}{suffix}"
+    
 class Integration(ABC):
     """Abstract base class for handling application integrations and authentication.
 
@@ -75,9 +82,8 @@ class ApiKeyIntegration(Integration):
     """
 
     def __init__(self, name: str, store: Store = None, **kwargs):
-        super().__init__(name, store, **kwargs)
-        if not name.endswith("api_key"):
-            self.name = f"{name}_api_key"
+        sanitized_name = sanitize_api_key_name(name)
+        super().__init__(sanitized_name, store, **kwargs)
         logger.info(f"Initializing API Key Integration: {name} with store: {store}")
 
     def get_credentials(self):

universal_mcp/logger.py

@@ -0,0 +1,74 @@
+import os
+import sys
+import uuid
+from functools import lru_cache
+
+from loguru import logger
+
+
+@lru_cache(maxsize=1)
+def get_version():
+    """
+    Get the version of the Universal MCP
+    """
+    try:
+        from importlib.metadata import version
+
+        print(version("universal_mcp"))
+        return version("universal_mcp")
+    except ImportError:
+        return "unknown"
+
+
+def get_user_id():
+    """
+    Generate a unique user ID for the current session
+    """
+    return "universal_" + str(uuid.uuid4())[:8]
+
+
+def posthog_sink(message, user_id=get_user_id()):
+    """
+    Custom sink for sending logs to PostHog
+    """
+    try:
+        import posthog
+
+        posthog.host = "https://us.i.posthog.com"
+        posthog.api_key = "phc_6HXMDi8CjfIW0l04l34L7IDkpCDeOVz9cOz1KLAHXh8"
+
+        record = message.record
+        properties = {
+            "level": record["level"].name,
+            "module": record["name"],
+            "function": record["function"],
+            "line": record["line"],
+            "message": record["message"],
+            "version": get_version(),
+        }
+        posthog.capture(user_id, "universal_mcp", properties)
+    except Exception:
+        # Silently fail if PostHog capture fails - don't want logging to break the app
+        pass
+
+
+def setup_logger():
+    logger.remove()
+    logger.add(
+        sink=sys.stdout,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        level="INFO",
+        colorize=True,
+    )
+    logger.add(
+        sink=sys.stderr,
+        format="<red>{time:YYYY-MM-DD HH:mm:ss}</red> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        level="ERROR",
+        colorize=True,
+    )
+    telemetry_enabled = os.getenv("TELEMETRY_ENABLED", "true").lower() == "true"
+    if telemetry_enabled:
+        logger.add(posthog_sink, level="INFO")  # PostHog telemetry
+
+
+setup_logger()