universal-mcp-applications 0.1.1__py3-none-any.whl

universal_mcp/applications/google-searchconsole/README.md

@@ -0,0 +1,21 @@
+# GoogleSearchconsoleApp MCP Server
+
+An MCP Server for the GoogleSearchconsoleApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the GoogleSearchconsoleApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `get_sitemap` | Retrieves information about a specific sitemap. |
+| `list_sitemaps` | Lists the sitemaps-entries submitted for this site, or included in the sitemap index file  |
+| `submit_sitemap` | Submits a sitemap for a site. Typically returns HTTP 204 No Content on success. |
+| `delete_sitemap` | Deletes a sitemap from this site. Typically returns HTTP 204 No Content on success. |
+| `get_site` | Retrieves information about a specific site. |
+| `list_sites` | Lists the user's Search Console sites. |
+| `add_site` | Adds a site to the set of the user's sites in Search Console. |
+| `delete_site` | Removes a site from the set of the user's Search Console sites. |
+| `index_inspect_url` | Inspects a URL in Google Index and provides information about its status. |
+| `query_search_analytics` | Queries your search traffic data with filters and parameters that you define. |

universal_mcp/applications/google-searchconsole/__init__.py

@@ -0,0 +1 @@
+from .app import GoogleSearchconsoleApp

universal_mcp/applications/google-searchconsole/app.py

@@ -0,0 +1,320 @@
+import logging
+import urllib.parse
+from typing import Any
+
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+logger = logging.getLogger(__name__)
+
+
+class GoogleSearchconsoleApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        super().__init__(name="google-searchconsole", integration=integration, **kwargs)
+        self.webmasters_base_url = "https://www.googleapis.com/webmasters/v3"
+        self.searchconsole_base_url = "https://searchconsole.googleapis.com/v1"
+
+    def delete_sitemap(self, siteUrl: str, feedpath: str) -> None:
+        """
+        Deletes a sitemap from this site. Typically returns HTTP 204 No Content on success.
+
+        Args:
+            siteUrl (str): The site's URL, including protocol (e.g. 'http://www.example.com/').
+            feedpath (str): The URL of the sitemap to delete. Example: 'http://www.example.com/sitemap.xml'.
+
+        Returns:
+            None: If the request is successful.
+
+        Tags:
+            sitemap_management
+        """
+        # Encode URL parts used as path segments
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        feedpath_encoded = urllib.parse.quote(feedpath, safe="")
+
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}/sitemaps/{feedpath_encoded}"
+        response = self._delete(url)
+        response.raise_for_status()
+
+    def get_sitemap(self, siteUrl: str, feedpath: str) -> dict[str, Any]:
+        """
+        Retrieves information about a specific sitemap.
+
+        Args:
+            siteUrl (str): The site's URL, including protocol (e.g. 'http://www.example.com/').
+            feedpath (str): The URL of the sitemap to retrieve. Example: 'http://www.example.com/sitemap.xml'.
+
+        Returns:
+            Dict[str, Any]: Sitemap resource.
+
+        Tags:
+            sitemap_management
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        feedpath_encoded = urllib.parse.quote(feedpath, safe="")
+
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}/sitemaps/{feedpath_encoded}"
+        response = self._get(url)
+        response.raise_for_status()
+        return response.json()
+
+    def list_sitemaps(
+        self, siteUrl: str, sitemapIndex: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Lists the sitemaps-entries submitted for this site, or included in the sitemap index file
+        (if sitemapIndex is specified in the request).
+
+        Args:
+            siteUrl (str): The site's URL, including protocol (e.g. 'http://www.example.com/').
+            sitemapIndex (Optional[str]): The URL of the sitemap index.
+                                          Example: 'http://www.example.com/sitemap_index.xml'.
+
+        Returns:
+            Dict[str, Any]: List of sitemap resources.
+
+        Tags:
+            sitemap_management, important
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}/sitemaps"
+
+        query_params = {}
+        if sitemapIndex is not None:
+            query_params["sitemapIndex"] = sitemapIndex
+
+        response = self._get(url, params=query_params if query_params else None)
+        response.raise_for_status()
+        return response.json()
+
+    def submit_sitemap(self, siteUrl: str, feedpath: str) -> None:
+        """
+        Submits a sitemap for a site. Typically returns HTTP 204 No Content on success.
+
+        Args:
+            siteUrl (str): The site's URL, including protocol (e.g. 'http://www.example.com/').
+            feedpath (str): The URL of the sitemap to submit. Example: 'http://www.example.com/sitemap.xml'.
+
+        Returns:
+            None: If the request is successful.
+
+        Tags:
+            sitemap_management
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        feedpath_encoded = urllib.parse.quote(feedpath, safe="")
+
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}/sitemaps/{feedpath_encoded}"
+        # PUT requests for submitting/notifying often don't have a body.
+        response = self._put(url, data=None)
+        response.raise_for_status()
+
+    # --- Sites ---
+
+    def add_site(self, siteUrl: str) -> dict[str, Any]:
+        """
+        Adds a site to the set of the user's sites in Search Console.
+        This will require verification of the site ownership.
+        If successful, this method returns a site resource in the response body.
+
+        Args:
+            siteUrl (str): The URL of the site to add. Example: 'http://www.example.com/'.
+
+        Returns:
+            Dict[str, Any]: Site resource upon successful addition.
+
+        Tags:
+            site_management, important
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}"
+        # This specific PUT for adding a site generally does not require a body;
+        # the resource identifier is the siteUrl itself.
+        # Google API docs state it returns a site resource.
+        response = self._put(url, data=None)
+        response.raise_for_status()
+        return response.json()
+
+    def delete_site(self, siteUrl: str) -> None:
+        """
+        Removes a site from the set of the user's Search Console sites.
+        Typically returns HTTP 204 No Content on success.
+
+        Args:
+            siteUrl (str): The URL of the site to delete. Example: 'http://www.example.com/'.
+
+        Returns:
+            None: If the request is successful.
+
+        Tags:
+            site_management
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}"
+        response = self._delete(url)
+        response.raise_for_status()
+
+    def get_site(self, siteUrl: str) -> dict[str, Any]:
+        """
+        Retrieves information about a specific site.
+
+        Args:
+            siteUrl (str): The site's URL, including protocol (e.g. 'http://www.example.com/').
+
+        Returns:
+            Dict[str, Any]: Site resource.
+
+        Tags:
+            site_management
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        url = f"{self.webmasters_base_url}/sites/{siteUrl_encoded}"
+        response = self._get(url)
+        response.raise_for_status()
+        return response.json()
+
+    def list_sites(self) -> dict[str, Any]:
+        """
+        Lists the user's Search Console sites.
+
+        Returns:
+            Dict[str, Any]: List of site resources.
+
+        Tags:
+            site_management
+        """
+        url = f"{self.webmasters_base_url}/sites"
+        response = self._get(url)
+        response.raise_for_status()
+        return response.json()
+
+    # --- URL Inspection ---
+
+    def index_inspect_url(
+        self, inspectionUrl: str, siteUrl: str, languageCode: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Inspects a URL in Google Index and provides information about its status.
+
+        Args:
+            inspectionUrl (str): The URL to inspect. Example: 'https://www.example.com/mypage'.
+            siteUrl (str): The site URL (property) to inspect the URL under.
+                           Must be a property in Search Console. Example: 'sc-domain:example.com' or 'https://www.example.com/'.
+            languageCode (Optional[str]): Optional. The BCP-47 language code for the inspection. Example: 'en-US'.
+
+        Returns:
+            Dict[str, Any]: Inspection result containing details about the URL's indexing status.
+
+        Tags:
+            url_inspection, indexing
+        """
+        url = f"{self.searchconsole_base_url}/urlInspection/index:inspect"
+        request_body: dict[str, Any] = {
+            "inspectionUrl": inspectionUrl,
+            "siteUrl": siteUrl,
+        }
+        if languageCode is not None:
+            request_body["languageCode"] = languageCode
+
+        # Assuming _post handles dict as JSON payload, similar to ExaApp
+        response = self._post(url, data=request_body)
+        response.raise_for_status()
+        return response.json()
+
+    # --- Search Analytics ---
+
+    def query_search_analytics(
+        self,
+        siteUrl: str,
+        startDate: str,
+        endDate: str,
+        dimensions: list[str] | None = None,
+        dimensionFilterGroups: list[dict[str, Any]] | None = None,
+        aggregationType: str | None = None,
+        rowLimit: int | None = None,
+        startRow: int | None = None,
+        dataState: str | None = None,
+        search_type: str | None = None,  # 'type' is a reserved keyword in Python
+    ) -> dict[str, Any]:
+        """
+        Queries your search traffic data with filters and parameters that you define.
+        The method returns zero or more rows grouped by the row that you define.
+        You must define a date range of one or more days.
+
+        Args:
+            siteUrl (str): The site's URL, including protocol (e.g. 'http://www.example.com/').
+            startDate (str): Start date of the requested period in YYYY-MM-DD format.
+            endDate (str): End date of the requested period in YYYY-MM-DD format.
+            dimensions (Optional[List[str]]): List of dimensions to group the data by.
+                Possible values: "date", "query", "page", "country", "device", "searchAppearance".
+                Example: ["date", "query"].
+            dimensionFilterGroups (Optional[List[Dict[str, Any]]]): Filter the results by dimensions.
+                Example: [{
+                    "groupType": "and",
+                    "filters": [{
+                        "dimension": "country",
+                        "operator": "equals",
+                        "expression": "USA"
+                    }, {
+                        "dimension": "device",
+                        "operator": "equals",
+                        "expression": "DESKTOP"
+                    }]
+                }]
+            aggregationType (Optional[str]): How data is aggregated.
+                Possible values: "auto", "byPage", "byProperty". Default is "auto".
+            rowLimit (Optional[int]): The maximum number of rows to return. Default is 1000. Max 25000.
+            startRow (Optional[int]): Zero-based index of the first row to return. Default is 0.
+            dataState (Optional[str]): Whether to filter for fresh data or all data.
+                Possible values: "all", "final". Default "all".
+            search_type (Optional[str]): Filter by search type.
+                Example: "web", "image", "video", "news", "discover", "googleNews".
+                This corresponds to the 'type' parameter in the API.
+
+        Returns:
+            Dict[str, Any]: Search analytics data.
+
+        Tags:
+            search_analytics, reporting
+        """
+        siteUrl_encoded = urllib.parse.quote(siteUrl, safe="")
+        url = (
+            f"{self.webmasters_base_url}/sites/{siteUrl_encoded}/searchAnalytics/query"
+        )
+
+        request_body: dict[str, Any] = {
+            "startDate": startDate,
+            "endDate": endDate,
+        }
+        if dimensions is not None:
+            request_body["dimensions"] = dimensions
+        if dimensionFilterGroups is not None:
+            request_body["dimensionFilterGroups"] = dimensionFilterGroups
+        if aggregationType is not None:
+            request_body["aggregationType"] = aggregationType
+        if rowLimit is not None:
+            request_body["rowLimit"] = rowLimit
+        if startRow is not None:
+            request_body["startRow"] = startRow
+        if dataState is not None:
+            request_body["dataState"] = dataState
+        if search_type is not None:
+            request_body["type"] = search_type  # API expects 'type'
+
+        response = self._post(url, data=request_body)
+        response.raise_for_status()
+        return response.json()
+
+    def list_tools(self):
+        return [
+            self.get_sitemap,
+            self.list_sitemaps,
+            self.submit_sitemap,
+            self.delete_sitemap,
+            self.get_site,
+            self.list_sites,
+            self.add_site,
+            self.delete_site,
+            self.index_inspect_url,
+            self.query_search_analytics,
+        ]

universal_mcp/applications/google-sheet/README.md

@@ -0,0 +1,36 @@
+# GoogleSheetApp MCP Server
+
+An MCP Server for the GoogleSheetApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the GoogleSheetApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `create_spreadsheet` | Creates a new blank Google Spreadsheet with the specified title and returns the API response. |
+| `get_spreadsheet` | Retrieves detailed information about a specific Google Spreadsheet using its ID  excluding cell data. |
+| `batch_get_values` | Retrieves multiple ranges of values from a Google Spreadsheet in a single batch request. |
+| `insert_dimensions` | Inserts new rows or columns into a Google Sheet at a specific position within the sheet. |
+| `append_dimensions` | Appends empty rows or columns to the end of a Google Sheet. |
+| `delete_dimensions` | Tool to delete specified rows or columns from a sheet in a google spreadsheet. use when you need to remove a range of rows or columns. |
+| `add_sheet` | Adds a new sheet (worksheet) to a spreadsheet. use this tool to create a new tab within an existing google sheet, optionally specifying its title, index, size, and other properties. |
+| `delete_sheet` | Tool to delete a sheet (worksheet) from a spreadsheet. use when you need to remove a specific sheet from a google sheet document. |
+| `add_basic_chart` | Adds a basic chart to a Google Spreadsheet like a column chart, bar chart, line chart and  area chart. |
+| `add_pie_chart` | Adds a pie chart to a Google Spreadsheet. |
+| `add_table` | Adds a table to a Google Spreadsheet. |
+| `update_table` | Updates an existing table in a Google Spreadsheet. |
+| `clear_values` | Clears all values from a specified range in a Google Spreadsheet while preserving cell formatting and other properties |
+| `update_values` | Updates cell values in a specified range of a Google Spreadsheet using the Sheets API |
+| `batch_update` | Updates a specified range in a google sheet with given values, or appends them as new rows if `first cell location` is omitted; ensure the target sheet exists and the spreadsheet contains at least one worksheet. |
+| `clear_basic_filter` | Tool to clear the basic filter from a sheet. use when you need to remove an existing basic filter from a specific sheet within a google spreadsheet. |
+| `list_tables` | This action is used to list all tables in a google spreadsheet, call this action to get the list of tables in a spreadsheet. discover all tables in a google spreadsheet by analyzing sheet structure and detecting data patterns. uses heuristic analysis to find header rows, data boundaries, and table structures. |
+| `get_values` | Retrieves values from a specific range in a Google Spreadsheet. |
+| `get_table_schema` | Analyzes table structure and infers column names, types, and constraints. |
+| `set_basic_filter` | Tool to set a basic filter on a sheet in a google spreadsheet. use when you need to filter or sort data within a specific range on a sheet. |
+| `copy_to_sheet` | Tool to copy a single sheet from a spreadsheet to another spreadsheet. Use when you need to duplicate a sheet into a different spreadsheet. |
+| `append_values` | Tool to append values to a spreadsheet. use when you need to add new data to the end of an existing table in a google sheet. |
+| `batch_clear_values` | Tool to clear one or more ranges of values from a spreadsheet. use when you need to remove data from specific cells or ranges while keeping formatting and other properties intact. |
+| `batch_get_values_by_data_filter` | Tool to return one or more ranges of values from a spreadsheet that match the specified data filters. use when you need to retrieve specific data sets based on filtering criteria rather than entire sheets or fixed ranges. |
+| `format_cells` | Applies comprehensive cell formatting to a specified range in a Google Sheets worksheet. |

universal_mcp/applications/google-sheet/__init__.py

@@ -0,0 +1 @@
+from .app import GoogleSheetApp