universal-mcp-applications 0.1.30rc1__tar.gz → 0.1.33__tar.gz

{universal_mcp_applications-0.1.30rc1 → universal_mcp_applications-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.30rc1
+Version: 0.1.33
 Summary: A Universal MCP Application: universal_mcp_applications
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_applications-0.1.30rc1 → universal_mcp_applications-0.1.33}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-applications"
-version = "0.1.30-rc1"
+version = "0.1.33"
 description = "A Universal MCP Application: universal_mcp_applications"
 readme = "README.md"
 requires-python = ">=3.11"

{universal_mcp_applications-0.1.30rc1 → universal_mcp_applications-0.1.33}/src/scripts/run_docgen.py

@@ -2,7 +2,7 @@ import os
 import subprocess
 
 APPS = [
-    "scraper",
+    "linkedin",
 ]
 
 

{universal_mcp_applications-0.1.30rc1 → universal_mcp_applications-0.1.33}/src/universal_mcp/applications/google_docs/app.py

@@ -11,7 +11,7 @@ class GoogleDocsApp(APIApplication):
 
     def create_document(self, title: str) -> dict[str, Any]:
         """
-        Creates a blank Google Document with a specified title by sending a POST request to the Google Docs API. The function returns a dictionary containing the new document's metadata, including the unique document ID required by other functions for subsequent modifications or retrieval.
+        Creates a blank Google Document with a specified title by sending a POST request to the Google Docs API. The function returns a dictionary containing the new document's metadata, including the unique document ID required by other functions for subsequent modifications or retrieval. Note that you need to call other google_docs functions (e.g. `google_docs__insert_text`) to actually add content after creating the document.
         
         Args:
             title: The title for the new Google Document to be created.
@@ -30,7 +30,11 @@ class GoogleDocsApp(APIApplication):
         document_data = {"title": title}
         response = self._post(url, data=document_data)
         response.raise_for_status()
-        return response.json()
+        payload = response.json()
+        payload["Note"] = (
+            "You must load and call other google docs content functions (like google_docs__insert_text)"
+        )
+        return payload
 
     def get_document(self, document_id: str) -> dict[str, Any]:
         """

{universal_mcp_applications-0.1.30rc1 → universal_mcp_applications-0.1.33}/src/universal_mcp/applications/google_sheet/app.py

@@ -21,7 +21,7 @@ class GoogleSheetApp(APIApplication):
 
     def create_spreadsheet(self, title: str) -> dict[str, Any]:
         """
-        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a worksheet (tab) to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata.
+        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a worksheet (tab) to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata. Note that you need to call other google_sheet functions (e.g. `google_sheet__write_values_to_sheet`) to actually add content after creating the spreadsheet.
 
         Args:
             title: String representing the desired title for the new spreadsheet
@@ -39,7 +39,11 @@ class GoogleSheetApp(APIApplication):
         url = self.base_url
         spreadsheet_data = {"properties": {"title": title}}
         response = self._post(url, data=spreadsheet_data)
-        return self._handle_response(response)
+        payload = self._handle_response(response)
+        payload["Note"] = (
+            "You must load and call other google_sheet content functions (like `google_sheet__write_values_to_sheet`)"
+        )
+        return payload
 
     def get_spreadsheet_metadata(self, spreadsheetId: str) -> dict[str, Any]:
         """

universal_mcp_applications-0.1.33/src/universal_mcp/applications/linkedin/README.md

@@ -0,0 +1,29 @@
+# LinkedinApp MCP Server
+
+An MCP Server for the LinkedinApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the LinkedinApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `list_all_chats` | Retrieves a paginated list of all chat conversations across linked accounts. Supports filtering by unread status, date range, and account provider, distinguishing it from functions listing messages within a single chat. |
+| `list_chat_messages` | Retrieves messages from a specific chat identified by `chat_id`. Supports pagination and filtering by date or sender. Unlike `list_all_messages`, which fetches from all chats, this function targets the contents of a single conversation. |
+| `send_chat_message` | Sends a text message to a specific chat conversation using its `chat_id`. This function creates a new message via a POST request, distinguishing it from read-only functions like `list_chat_messages`. It returns the API's response, which typically confirms the successful creation of the message. |
+| `retrieve_chat` | Retrieves a single chat's details using its Unipile or provider-specific ID. This function is distinct from `list_all_chats`, which returns a collection, by targeting one specific conversation. |
+| `list_all_messages` | Retrieves a paginated list of messages from all chats associated with the account. Unlike `list_chat_messages` which targets a specific conversation, this function provides a global message view, filterable by sender and date range. |
+| `list_profile_posts` | Retrieves a paginated list of posts from a specific user or company profile using their provider ID. An authorizing `account_id` is required, and the `is_company` flag must specify the entity type, distinguishing this from `retrieve_post` which fetches a single post by its own ID. |
+| `retrieve_own_profile` | Retrieves the profile details for the user associated with the Unipile account. This function targets the API's 'me' endpoint to fetch the authenticated user's profile, distinct from `retrieve_user_profile` which fetches profiles of other users by their public identifier. |
+| `retrieve_user_profile` | Retrieves a specific LinkedIn user's profile using their public or internal ID. Unlike `retrieve_own_profile`, which fetches the authenticated user's details, this function targets and returns data for any specified third-party user profile on the platform. |
+| `retrieve_post` | Fetches a specific post's details by its unique ID. Unlike `list_profile_posts`, which retrieves a collection of posts from a user or company profile, this function targets one specific post and returns its full object. |
+| `list_post_comments` | Fetches comments for a specific post. Providing an optional `comment_id` retrieves threaded replies instead of top-level comments. This read-only operation contrasts with `create_post_comment`, which publishes new comments, and `list_content_reactions`, which retrieves 'likes'. |
+| `create_post` | Publishes a new top-level post from the account, including text, user mentions, and an external link. This function creates original content, distinguishing it from `create_post_comment` which adds replies to existing posts. |
+| `list_content_reactions` | Retrieves a paginated list of reactions for a given post or, optionally, a specific comment. This read-only operation uses the account for the request, distinguishing it from the `create_reaction` function which adds new reactions. |
+| `create_post_comment` | Publishes a comment on a specified post. By providing an optional `comment_id`, it creates a threaded reply to an existing comment instead of a new top-level one. This function's dual capability distinguishes it from `list_post_comments`, which only retrieves comments and their replies. |
+| `create_reaction` | Adds a specified reaction (e.g., 'like', 'love') to a LinkedIn post or, optionally, to a specific comment. This function performs a POST request to create the reaction, differentiating it from `list_content_reactions` which only retrieves existing ones. |
+| `search_companies` | Performs a paginated search for companies on LinkedIn using keywords, with optional location and industry filters. Its specific 'companies' search category distinguishes it from other methods like `search_people` or `search_posts`, ensuring that only company profiles are returned. |
+| `search_jobs` | Performs a LinkedIn search for jobs, filtering results by keywords, region, industry, and minimum salary. Unlike other search functions (`search_people`, `search_companies`), this method is specifically configured to query the 'jobs' category, providing a paginated list of relevant employment opportunities. |
+| `search_people` | Searches for LinkedIn user profiles using keywords, with optional filters for location, industry, and company. This function specifically targets the 'people' category, distinguishing it from other search methods like `search_companies` or `search_jobs` that query different entity types through the same API endpoint. |
+| `search_posts` | Performs a keyword-based search for LinkedIn posts, allowing filters for date and sorting by relevance. This function executes a general, platform-wide content search, distinguishing it from other search functions that target people, companies, or jobs, and from `list_profile_posts` which retrieves from a specific profile. |

{universal_mcp_applications-0.1.30rc1 → universal_mcp_applications-0.1.33}/src/universal_mcp/applications/linkedin/app.py

@@ -78,6 +78,38 @@ class LinkedinApp(APIApplication):
             "Cache-Control": "no-cache",  # Often good practice for APIs
         }
 
+    def _get_search_parameter_id(self, param_type: str, keywords: str) -> str:
+        """
+        Retrieves the ID for a given LinkedIn search parameter by its name.
+
+        Args:
+            param_type: The type of parameter to search for (e.g., "LOCATION", "COMPANY").
+            keywords: The name of the parameter to find (e.g., "United States").
+
+        Returns:
+            The corresponding ID for the search parameter.
+
+        Raises:
+            ValueError: If no exact match for the keywords is found.
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search/parameters"
+        params = {
+            "account_id": self.account_id,
+            "keywords": keywords,
+            "type": param_type,
+        }
+
+        response = self._get(url, params=params)
+        results = self._handle_response(response)
+
+        items = results.get("items", [])
+        if items:
+            # Return the ID of the first result, assuming it's the most relevant
+            return items[0]["id"]
+
+        raise ValueError(f'Could not find a matching ID for {param_type}: "{keywords}"')
+
     def list_all_chats(
         self,
         unread: bool | None = None,
@@ -271,54 +303,6 @@ class LinkedinApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
-    def list_all_accounts(
-        self,
-        cursor: str | None = None,
-        limit: int | None = None,  # 1-259 according to spec
-    ) -> dict[str, Any]:
-        """
-        Retrieves a paginated list of all social media accounts linked to the Unipile service. This is crucial for obtaining the `account_id` required by other methods to specify which user account should perform an action, like sending a message or retrieving user-specific posts.
-
-        Args:
-            cursor: Pagination cursor.
-            limit: Number of items to return (1-259).
-
-        Returns:
-            A dictionary containing a list of account objects and a pagination cursor.
-
-        Raises:
-            httpx.HTTPError: If the API request fails.
-
-        Tags:
-            linkedin, account, list, unipile, api, important
-        """
-        url = f"{self.base_url}/api/v1/accounts"
-        params: dict[str, Any] = {}
-        if cursor:
-            params["cursor"] = cursor
-        if limit:
-            params["limit"] = limit
-
-        response = self._get(url, params=params)
-        return response.json()
-
-    # def retrieve_linked_account(self) -> dict[str, Any]:
-    #     """
-    #     Retrieves details for the account linked to Unipile. It fetches metadata about the connection itself (e.g., a linked LinkedIn account), differentiating it from `retrieve_user_profile` which fetches a user's profile from the external platform.
-
-    #     Returns:
-    #         A dictionary containing the account object details.
-
-    #     Raises:
-    #         httpx.HTTPError: If the API request fails.
-
-    #     Tags:
-    #         linkedin, account, retrieve, get, unipile, api, important
-    #     """
-    #     url = f"{self.base_url}/api/v1/accounts/{self.account_id}"
-    #     response = self._get(url)
-    #     return response.json()
-
     def list_profile_posts(
         self,
         identifier: str,  # User or Company provider internal ID
@@ -602,43 +586,53 @@ class LinkedinApp(APIApplication):
                 "message": "Reaction action processed.",
             }
 
-    def search(
+    def retrieve_user_profile(self, identifier: str) -> dict[str, Any]:
+        """
+        Retrieves a specific LinkedIn user's profile using their public or internal ID. Unlike `retrieve_own_profile`, which fetches the authenticated user's details, this function targets and returns data for any specified third-party user profile on the platform.
+
+        Args:
+            identifier: Can be the provider's internal id OR the provider's public id of the requested user.For example, for https://www.linkedin.com/in/manojbajaj95/, the identifier is "manojbajaj95".
+
+        Returns:
+            A dictionary containing the user's profile details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, profile, retrieve, get, api, important
+        """
+        url = f"{self.base_url}/api/v1/users/{identifier}"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        response = self._get(url, params=params)
+        return self._handle_response(response)
+
+    def search_people(
         self,
-        category: Literal["people", "companies", "posts", "jobs"],
         cursor: str | None = None,
         limit: int | None = None,
         keywords: str | None = None,
-        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
-        sort_by: Literal["relevance", "date"] = "relevance",
-        minimum_salary_value: int = 40,
+        location: str | None = None,
+        industry: str | None = None,
+        company: str | None = None,
     ) -> dict[str, Any]:
         """
-        Performs a comprehensive LinkedIn search for people, companies, posts, or jobs using keywords.
-        Supports pagination and targets either the classic or Sales Navigator API for posts.
-        For people, companies, and jobs, it uses the classic API.
-
+        Searches for LinkedIn user profiles using keywords, with optional filters for location, industry, and company. This function specifically targets the 'people' category, distinguishing it from other search methods like `search_companies` or `search_jobs` that query different entity types through the same API endpoint.
+        
         Args:
-            category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (up to 50 for Classic search).
             keywords: Keywords to search for.
-            date_posted: Filter by when the post was posted (posts only). Valid values are "past_day", "past_week", or "past_month".
-            sort_by: How to sort the results (for posts and jobs). Valid values are "relevance" or "date".
-            minimum_salary_value: The minimum salary to filter for (jobs only).
-
+            location: The geographical location to filter people by (e.g., "United States").
+            industry: The industry to filter people by.(eg., "Information Technology and Services").
+            company: The company to filter people by.(e.g., "Google").
+        
         Returns:
             A dictionary containing search results and pagination details.
-
+        
         Raises:
             httpx.HTTPError: If the API request fails.
-            ValueError: If the category is empty.
-
-        Tags:
-            linkedin, search, people, companies, posts, jobs, api, important
         """
-        if not category:
-            raise ValueError("Category cannot be empty.")
-
         url = f"{self.base_url}/api/v1/linkedin/search"
 
         params: dict[str, Any] = {"account_id": self.account_id}
@@ -647,47 +641,179 @@ class LinkedinApp(APIApplication):
         if limit is not None:
             params["limit"] = limit
 
-        payload: dict[str, Any] = {"api": "classic", "category": category}
+        payload: dict[str, Any] = {"api": "classic", "category": "people"}
 
         if keywords:
             payload["keywords"] = keywords
+            
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
 
-        if category == "posts":
-            if date_posted:
-                payload["date_posted"] = date_posted
-            if sort_by:
-                payload["sort_by"] = sort_by
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        
+        if company:
+            company_id = self._get_search_parameter_id("COMPANY", company)
+            payload["company"] = [company_id]
+        
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
 
-        elif category == "jobs":
-            payload["minimum_salary"] = {
-                "currency": "USD",
-                "value": minimum_salary_value,
-            }
-            if sort_by:
-                payload["sort_by"] = sort_by
+    def search_companies(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        location: str | None = None,
+        industry: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Performs a paginated search for companies on LinkedIn using keywords, with optional location and industry filters. Its specific 'companies' search category distinguishes it from other methods like `search_people` or `search_posts`, ensuring that only company profiles are returned.
+        
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            location: The geographical location to filter companies by (e.g., "United States").
+            industry: The industry to filter companies by.(e.g., "Information Technology and Services").
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {"api": "classic", "category": "companies"}
+
+        if keywords:
+            payload["keywords"] = keywords
+
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
+            
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
 
         response = self._post(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def retrieve_user_profile(self, identifier: str) -> dict[str, Any]:
+    def search_posts(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+    ) -> dict[str, Any]:
         """
-        Retrieves a specific LinkedIn user's profile using their public or internal ID. Unlike `retrieve_own_profile`, which fetches the authenticated user's details, this function targets and returns data for any specified third-party user profile on the platform.
-
+        Performs a keyword-based search for LinkedIn posts, allowing filters for date and sorting by relevance. This function executes a general, platform-wide content search, distinguishing it from other search functions that target people, companies, or jobs, and from `list_profile_posts` which retrieves from a specific profile.
+        
         Args:
-            identifier: Can be the provider's internal id OR the provider's public id of the requested user.For example, for https://www.linkedin.com/in/manojbajaj95/, the identifier is "manojbajaj95".
-
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            date_posted: Filter by when the post was posted.
+            sort_by: How to sort the results.
+        
         Returns:
-            A dictionary containing the user's profile details.
-
+            A dictionary containing search results and pagination details.
+        
         Raises:
             httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
 
-        Tags:
-            linkedin, user, profile, retrieve, get, api, important
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {"api": "classic", "category": "posts"}
+
+        if keywords:
+            payload["keywords"] = keywords
+        if date_posted:
+            payload["date_posted"] = date_posted
+        if sort_by:
+            payload["sort_by"] = sort_by
+
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    def search_jobs(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        region: str | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+        minimum_salary_value: int = 40,
+        industry: str | None = None,
+    ) -> dict[str, Any]:
         """
-        url = f"{self.base_url}/api/v1/users/{identifier}"
+        Performs a LinkedIn search for jobs, filtering results by keywords, region, industry, and minimum salary. Unlike other search functions (`search_people`, `search_companies`), this method is specifically configured to query the 'jobs' category, providing a paginated list of relevant employment opportunities.
+        
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            region: The geographical region to filter jobs by (e.g., "United States").
+            sort_by: How to sort the results.(e.g., "relevance" or "date".)
+            minimum_salary_value: The minimum salary to filter for.
+            industry: The industry to filter jobs by.(e.g., "Software Development").
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+            ValueError: If the specified location is not found.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
         params: dict[str, Any] = {"account_id": self.account_id}
-        response = self._get(url, params=params)
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {
+            "api": "classic",
+            "category": "jobs",
+            "minimum_salary": {
+                "currency": "USD",
+                "value": minimum_salary_value,
+            },
+        }
+
+        if keywords:
+            payload["keywords"] = keywords
+        if sort_by:
+            payload["sort_by"] = sort_by
+
+        # If location is provided, get its ID and add it to the payload
+        if region:
+            location_id = self._get_search_parameter_id("LOCATION", region)
+            payload["region"] = location_id
+            
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+
+        response = self._post(url, params=params, data=payload)
         return self._handle_response(response)
 
     def list_tools(self) -> list[Callable]:
@@ -697,8 +823,6 @@ class LinkedinApp(APIApplication):
             self.send_chat_message,
             self.retrieve_chat,
             self.list_all_messages,
-            self.list_all_accounts,
-            # self.retrieve_linked_account,
             self.list_profile_posts,
             self.retrieve_own_profile,
             self.retrieve_user_profile,
@@ -708,5 +832,8 @@ class LinkedinApp(APIApplication):
             self.list_content_reactions,
             self.create_post_comment,
             self.create_reaction,
-            self.search,
+            self.search_companies,
+            self.search_jobs,
+            self.search_people,
+            self.search_posts,
         ]

universal_mcp_applications-0.1.33/src/universal_mcp/applications/scraper/README.md

@@ -0,0 +1,18 @@
+# ScraperApp MCP Server
+
+An MCP Server for the ScraperApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the ScraperApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `linkedin_list_profile_posts` | Fetches a paginated list of posts from a specific user or company profile using its provider ID. The `is_company` flag must specify the entity type. Unlike `linkedin_search_posts`, this function directly retrieves content from a known profile's feed instead of performing a global keyword search. |
+| `linkedin_retrieve_profile` | Fetches a specific LinkedIn user's profile using their public or internal ID. Unlike `linkedin_search_people`, which discovers multiple users via keywords, this function targets and retrieves detailed data for a single, known individual based on a direct identifier. |
+| `linkedin_list_post_comments` | Fetches a paginated list of comments for a specified LinkedIn post. It can retrieve either top-level comments or threaded replies if an optional `comment_id` is provided. This is a read-only operation, distinct from functions that search for posts or list user-specific content. |
+| `linkedin_search_people` | Performs a paginated search for people on LinkedIn, distinct from searches for companies or jobs. It filters results using keywords, location, industry, and company, internally converting filter names like 'United States' into their required API IDs before making the request. |
+| `linkedin_search_companies` | Executes a paginated LinkedIn search for companies, filtering by optional keywords, location, and industry. Unlike `linkedin_search_people` or `linkedin_search_jobs`, this function specifically sets the API search category to 'companies' to ensure that only company profiles are returned in the search results. |
+| `linkedin_search_posts` | Performs a keyword-based search for LinkedIn posts, allowing results to be filtered by date and sorted by relevance. This function specifically queries the 'posts' category, distinguishing it from other search methods in the class that target people, companies, or jobs, and returns relevant content. |
+| `linkedin_search_jobs` | Executes a LinkedIn search specifically for job listings using keywords and filters like region, industry, and minimum salary. Unlike other search functions targeting people or companies, this is specialized for job listings and converts friendly filter names (e.g., "United States") into their required API IDs. |