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

universal_mcp/applications/notion/app.py

@@ -7,11 +7,11 @@ from universal_mcp.integrations import Integration
 class NotionApp(APIApplication):
     def __init__(self, integration: Integration = None, **kwargs) -> None:
         """
-        Initializes a new instance of the class with given integration and additional options.
+        Initializes a new instance of the Notion API app with a specified integration and additional parameters.
         
         Args:
-            integration: An optional Integration instance to configure the connection. Defaults to None.
-            **kwargs: Additional keyword arguments for configuration.
+            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
@@ -29,18 +29,19 @@ class NotionApp(APIApplication):
             "Authorization": f"Bearer {credentials['access_token']}",
             "Accept": "application/json",
             "Notion-Version": "2022-06-28",
-        }    
+        }     
 
-    def notion_retrieve_auser(self, id, request_body=None) -> dict[str, Any]:
+    def retrieve_a_user(self, id, request_body=None) -> dict[str, Any]:
         """
-        Retrieves user information from the Notion API by user ID.
+        Retrieves user details from the server using the specified user ID.
         
         Args:
-            id: The unique identifier of the user whose information is to be retrieved.
-            request_body: A dictionary representing the request body, optional, default is None.
+            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 the user's information from the Notion API.
+            A dictionary containing user details, as retrieved from the server response.
         """
         if id is None:
             raise ValueError("Missing required parameter 'id'")
@@ -50,15 +51,15 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_list_all_users(self, ) -> dict[str, Any]:
+    def list_all_users(self, ) -> dict[str, Any]:
         """
-        Fetches and returns a list of all users from the Notion API.
+        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 JSON response from the Notion API, representing all users data.
+            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 = {}
@@ -66,15 +67,15 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_your_token_sbot_user(self, ) -> dict[str, Any]:
+    def retrieve_your_token_sbot_user(self, ) -> dict[str, Any]:
         """
-        Retrieves the current user's token data from the Notion API.
+        Retrieves the authentication token for the current user from the SBOT service.
         
         Args:
-            self: Instance of the class containing the necessary configuration and authentication details for accessing the Notion API.
+            self: Instance of the class containing configuration such as 'base_url' and the '_get' method.
         
         Returns:
-            A dictionary containing the current user's token information as retrieved from the Notion API.
+            A dictionary containing the JSON response of the current user's token information.
         """
         url = f"{self.base_url}/v1/users/me"
         query_params = {}
@@ -82,15 +83,15 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_adatabase(self, id) -> dict[str, Any]:
+    def retrieve_a_database(self, id) -> dict[str, Any]:
         """
-        Retrieves a Notion database by its unique identifier.
+        Retrieves database details from a specified endpoint using the provided database ID.
         
         Args:
-            id: A string representing the unique identifier of the Notion database to be retrieved.
+            id: A unique identifier for the database to be retrieved. Must be a non-null value.
         
         Returns:
-            A dictionary containing the details of the retrieved Notion database.
+            A dictionary containing the details of the requested database.
         """
         if id is None:
             raise ValueError("Missing required parameter 'id'")
@@ -100,91 +101,86 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_update_adatabase(self, id, request_body=None) -> dict[str, Any]:
+    def update_a_database(self, id, request_body=None) -> dict[str, Any]:
         """
-        Updates a Notion database with the given ID and request body data.
+        Updates a database entry with the given ID using a PATCH request.
         
         Args:
-            self: An instance of the class containing configuration and methods for HTTP requests.
-            id: A string representing the unique identifier of the Notion database to be updated.
-            request_body: An optional dictionary containing the fields and values to update in the database.
+            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 Notion API after updating the database.
+            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={}, params=query_params)
+        response = self._patch(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_query_adatabase(self, id, request_body=None) -> dict[str, Any]:
+    def query_a_database(self, id, request_body=None) -> dict[str, Any]:
         """
-        Executes a query on a Notion database using the Notion API.
+        Executes a query on a specified database using an identifier and an optional request body.
         
         Args:
-            self: Instance of the class which should contain 'base_url' and '_post' method.
-            id: A string representing the unique identifier of the Notion database to query.
-            request_body: Optional. A dictionary representing the request body for the query. Defaults to None.
+            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 JSON response from the Notion API after querying the specified database.
+            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 = {}
-        json_body = request_body if request_body is not None else None
-        response = self._post(url, data=json_body, params=query_params)
+        response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_create_adatabase(self, request_body=None) -> dict[str, Any]:
+    def create_a_database(self, request_body=None) -> dict[str, Any]:
         """
-        Creates a new database in Notion using the provided request body.
+        Creates a new database on the server using the specified request body.
         
         Args:
-            self: Reference to the current instance of the class.
-            request_body: Optional dictionary containing the specifications for creating the Notion database. If None, a default empty request body is used.
+            request_body: A dictionary containing the data to be sent in the request body. Defaults to None if not provided.
         
         Returns:
-            A dictionary representing the JSON response from the Notion API, containing data about the newly created database.
+            A dictionary containing the server's JSON response from the database creation request.
         """
         url = f"{self.base_url}/v1/databases/"
         query_params = {}
-        json_body = request_body if request_body is not None else None
-        response = self._post(url, data=json_body, params=query_params)
+        response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_create_apage(self, request_body=None) -> dict[str, Any]:
+    def create_a_page(self, request_body=None) -> dict[str, Any]:
         """
-        Creates a new page in Notion by sending a POST request with the specified request body.
+        Creates a new page by sending a POST request to the specified endpoint.
         
         Args:
-            request_body: Optional; A dictionary containing the data to create a new page in Notion. Defaults to None.
+            request_body: Optional; A dictionary containing the data to be sent in the body of the POST request. Defaults to None.
         
         Returns:
-            A dictionary containing the JSON response from the Notion API with the details of the newly created page.
+            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 = {}
-        json_body = request_body if request_body is not None else None
-        response = self._post(url, data=json_body, params=query_params)
+        response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_apage(self, id) -> dict[str, Any]:
+    def retrieve_a_page(self, id) -> dict[str, Any]:
         """
-        Retrieves a page from the Notion API using a given page ID.
+        Retrieves a page by its unique identifier from a remote server.
         
         Args:
-            id: The unique identifier of the Notion page to be retrieved.
+            id: The unique identifier of the page to retrieve.
         
         Returns:
-            A dictionary containing the JSON response from the Notion API, representing the page data.
+            A dictionary containing the JSON response from the server, which represents the page data.
         """
         if id is None:
             raise ValueError("Missing required parameter 'id'")
@@ -194,36 +190,35 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_update_page_properties(self, id, request_body=None) -> dict[str, Any]:
+    def update_page_properties(self, id, request_body=None) -> dict[str, Any]:
         """
-        Updates the properties of a Notion page identified by a given ID.
+        Updates the properties of a page identified by its ID using the provided request body.
         
         Args:
-            self: Instance of the class containing the Notion API credentials and methods.
-            id: The unique identifier of the Notion page to update. Must not be None.
-            request_body: An optional dictionary representing the request body to be sent with the update request. Defaults to None, indicating no additional properties to update.
+            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 JSON response from the Notion API after the page update request.
+            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={}, params=query_params)
+        response = self._patch(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_apage_property_item(self, page_id, property_id) -> dict[str, Any]:
+    def retrieve_a_page_property_item(self, page_id, property_id) -> dict[str, Any]:
         """
-        Retrieves a specific property item from a page in Notion using the page and property IDs.
+        Retrieves the property item of a page using specified page and property identifiers.
         
         Args:
-            page_id: The unique identifier for the Notion page from which the property item should be retrieved.
-            property_id: The unique identifier for the property item within the specified page that should be retrieved.
+            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 containing the JSON response from the Notion API representing the requested property item.
+            A dictionary representing the JSON response with details of the property item.
         """
         if page_id is None:
             raise ValueError("Missing required parameter 'page_id'")
@@ -235,17 +230,16 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
+    def retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
         """
-        Retrieves the child blocks of a specified Notion block.
+        Retrieves the children of a specified block using its unique identifier.
         
         Args:
-            self: The instance of the class this method belongs to.
-            id: The unique identifier of the parent block whose children are to be retrieved.
-            page_size: Optional; the number of child blocks to retrieve per request.
+            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 JSON response with details about the child blocks.
+            A dictionary containing the data representing the children of the specified block.
         """
         if id is None:
             raise ValueError("Missing required parameter 'id'")
@@ -255,35 +249,35 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_append_block_children(self, id, request_body=None) -> dict[str, Any]:
+    def append_block_children(self, id, request_body=None) -> dict[str, Any]:
         """
-        Appends child blocks to a block in Notion using its API.
+        Appends child elements to a block identified by its ID and returns the updated block data.
         
         Args:
-            self: Instance of the class containing Notion API credentials and configuration.
-            id: The unique identifier of the parent block to which child blocks are to be appended.
-            request_body: An optional dictionary containing the block data to append. Defaults to None.
+            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 response from the Notion API, containing the result of the append operation.
+            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={}, params=query_params)
+        response = self._patch(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_ablock(self, id) -> dict[str, Any]:
+    def retrieve_a_block(self, id) -> dict[str, Any]:
         """
-        Retrieves a block from the Notion API using the specified block ID.
+        Retrieves a block of data from a given API endpoint using the specified block ID.
         
         Args:
-            id: The unique identifier of the block to retrieve from the Notion API. Must be a non-null string.
+            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 block data in JSON format as retrieved from the Notion API.
+            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'")
@@ -293,15 +287,15 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_delete_ablock(self, id) -> dict[str, Any]:
+    def delete_a_block(self, id) -> dict[str, Any]:
         """
-        Deletes a block from the Notion database using the specified block ID.
+        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 JSON response from the Notion API after attempting to delete the block.
+            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'")
@@ -311,53 +305,52 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_update_ablock(self, id, request_body=None) -> dict[str, Any]:
+    def update_a_block(self, id, request_body=None) -> dict[str, Any]:
         """
-        Updates a block in Notion with the given ID and request body.
+        Updates a block by sending a PATCH request to the specified endpoint.
         
         Args:
-            id: The unique identifier of the Notion block to update.
-            request_body: The request body containing the updates to be made to the block. Defaults to None if not provided.
+            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 Notion API after the block has been updated.
+            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={}, params=query_params)
+        response = self._patch(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_search(self, request_body=None) -> dict[str, Any]:
+    def search(self, request_body=None) -> dict[str, Any]:
         """
-        Executes a search request to the Notion API and returns the response in JSON format.
+        Executes a search query using the specified request body and returns the results.
         
         Args:
-            request_body: An optional dictionary containing the search parameters for the API request. Defaults to None if not provided.
+            request_body: An optional dictionary containing the data to be sent in the search request.
         
         Returns:
-            A dictionary containing the response from the Notion API in JSON format.
+            A dictionary containing the JSON-decoded response from the search operation.
         """
         url = f"{self.base_url}/v1/search"
         query_params = {}
-        json_body = request_body if request_body is not None else None
-        response = self._post(url, data=json_body, params=query_params)
+        response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def notion_retrieve_comments(self, block_id=None, page_size=None, request_body=None) -> dict[str, Any]:
+    def retrieve_comments(self, block_id=None, page_size=None, request_body=None) -> dict[str, Any]:
         """
-        Retrieves comments from a Notion block using the Notion API.
+        Fetches comments from a remote server for a specified block, with optional pagination.
         
         Args:
-            block_id: Optional; The ID of the block for which to retrieve comments. If None, it retrieves comments for all blocks available to the user.
-            page_size: Optional; The maximum number of comments to retrieve in one request. If None, the default page size will be used.
-            request_body: Optional; A dictionary to include additional parameters in the request body. If None, no extra parameters are added.
+            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 JSON response from the Notion API with the comments retrieved.
+            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}
@@ -365,51 +358,50 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def notion_add_comment_to_page(self, request_body=None) -> dict[str, Any]:
+    def add_comment_to_page(self, request_body=None) -> dict[str, Any]:
         """
-        Adds a comment to a specified Notion page using the provided request body.
+        Adds a comment to a page by sending a POST request with the provided request body.
         
         Args:
-            request_body: An optional dictionary containing the details of the comment to be added to the Notion page. If None, no data is sent in the request's body.
+            request_body: Optional; A dictionary containing the data for the comment to be added. Defaults to None.
         
         Returns:
-            A dictionary containing the response data from the Notion API, parsed from JSON format.
+            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 = {}
-        json_body = request_body if request_body is not None else None
-        response = self._post(url, data=json_body, params=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 that interact with Notion's API for various operations.
+        Returns a list of functions related to user and database operations.
         
         Args:
-            None: This method does not take any parameters.
+            self: The instance of the class to which the function belongs.
         
         Returns:
-            A list of functions that perform specific operations with Notion's API, such as retrieving or updating users, databases, pages, blocks, and comments.
+            A list of method references that pertain to various operations such as user retrieval, database operations, and page/block management.
         """
         return [
-            self.notion_retrieve_auser,
-            self.notion_list_all_users,
-            self.notion_retrieve_your_token_sbot_user,
-            self.notion_retrieve_adatabase,
-            self.notion_update_adatabase,
-            self.notion_query_adatabase,
-            self.notion_create_adatabase,
-            self.notion_create_apage,
-            self.notion_retrieve_apage,
-            self.notion_update_page_properties,
-            self.notion_retrieve_apage_property_item,
-            self.notion_retrieve_block_children,
-            self.notion_append_block_children,
-            self.notion_retrieve_ablock,
-            self.notion_delete_ablock,
-            self.notion_update_ablock,
-            self.notion_search,
-            self.notion_retrieve_comments,
-            self.notion_add_comment_to_page
+            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,
+        ]