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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.28
+Version: 0.1.30rc1
 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.28 → universal_mcp_applications-0.1.30rc1}/pyproject.toml

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

{universal_mcp_applications-0.1.28 → universal_mcp_applications-0.1.30rc1}/src/tests/test_applications.py

@@ -80,7 +80,6 @@ ALL_APPS = [
     "trello",
     "twilio",
     "twitter",
-    "unipile",
     "whatsapp",
     "whatsapp_business",
     "wrike",  # not seeded

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

@@ -1,16 +1,15 @@
 import json
-from collections.abc import Callable
-from typing import Any, Literal
+import os
+from typing import Any, Callable, Literal
 
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
 
-class UnipileApp(APIApplication):
+class LinkedinApp(APIApplication):
     """
-    Application for interacting with the LinkedIn API via Unipile.
-    Handles operations related to chats, messages, accounts, posts, and user profiles.
+    Base class for Universal MCP Applications.
     """
 
     def __init__(self, integration: Integration) -> None:
@@ -23,37 +22,31 @@ class UnipileApp(APIApplication):
                          via headers in `integration.get_credentials()`, e.g.,
                          `{"headers": {"x-api-key": "YOUR_API_KEY"}}`.
         """
-        super().__init__(name="unipile", integration=integration)
+        super().__init__(name="linkedin", integration=integration)
 
         self._base_url = None
+        self.account_id = None
+        if self.integration:
+            credentials = self.integration.get_credentials()
+            if credentials:
+                self.account_id = credentials.get("account_id")
 
     @property
     def base_url(self) -> str:
-        """
-        A property that lazily constructs and caches the Unipile API base URL from 'subdomain' and 'port' credentials. Built on first access and used by all API methods, it raises a ValueError if credentials are missing. This is the default construction, unlike the setter which allows manual override.
-        """
         if not self._base_url:
-            credentials = self.integration.get_credentials()
-            subdomain = credentials.get("subdomain")
-            port = credentials.get("port")
-            if not subdomain or not port:
+            unipile_dsn = os.getenv("UNIPILE_DSN")
+            if not unipile_dsn:
                 logger.error(
-                    "UnipileApp: Missing 'subdomain' or 'port' in integration credentials."
+                    "UnipileApp: UNIPILE_DSN environment variable is not set."
                 )
                 raise ValueError(
-                    "Integration credentials must include 'subdomain' and 'port'."
+                    "UnipileApp: UNIPILE_DSN environment variable is required."
                 )
-            self._base_url = f"https://{subdomain}.unipile.com:{port}"
+            self._base_url = f"https://{unipile_dsn}"
         return self._base_url
 
     @base_url.setter
     def base_url(self, base_url: str) -> None:
-        """
-        Sets or overrides the Unipile API's base URL. This setter allows manually changing the endpoint, bypassing the default URL that is dynamically constructed from integration credentials. It is primarily intended for testing against different environments or for custom deployments.
-
-        Args:
-            base_url: The new base URL to set.
-        """
         self._base_url = base_url
         logger.info(f"UnipileApp: Base URL set to {self._base_url}")
 
@@ -68,14 +61,7 @@ class UnipileApp(APIApplication):
             )
             return {}
 
-        credentials = self.integration.get_credentials()
-
-        api_key = (
-            credentials.get("api_key")
-            or credentials.get("API_KEY")
-            or credentials.get("apiKey")
-        )
-
+        api_key = os.getenv("UNIPILE_API_KEY")
         if not api_key:
             logger.error(
                 "UnipileApp: API key not found in integration credentials for Unipile."
@@ -100,10 +86,9 @@ class UnipileApp(APIApplication):
         after: str | None = None,  # ISO 8601 UTC datetime
         limit: int | None = None,  # 1-250
         account_type: str | None = None,
-        account_id: str | None = None,  # Comma-separated list of ids
     ) -> dict[str, Any]:
         """
-        Retrieves a paginated list of all chat conversations across linked accounts. Supports filtering by unread status, date range, account provider, and specific account IDs, distinguishing it from functions listing messages within a single chat.
+        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.
 
         Args:
             unread: Filter for unread chats only or read chats only.
@@ -112,7 +97,6 @@ class UnipileApp(APIApplication):
             after: Filter for items created after this ISO 8601 UTC datetime (exclusive).
             limit: Number of items to return (1-250).
             account_type: Filter by provider (e.g., "linkedin").
-            account_id: Filter by specific account IDs (comma-separated).
 
         Returns:
             A dictionary containing a list of chat objects and a pagination cursor.
@@ -125,6 +109,9 @@ class UnipileApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats"
         params: dict[str, Any] = {}
+        
+        params["account_id"] = self.account_id
+        
         if unread is not None:
             params["unread"] = unread
         if cursor:
@@ -137,8 +124,7 @@ class UnipileApp(APIApplication):
             params["limit"] = limit
         if account_type:
             params["account_type"] = account_type
-        if account_id:
-            params["account_id"] = account_id
+            
 
         response = self._get(url, params=params)
         return response.json()
@@ -216,15 +202,12 @@ class UnipileApp(APIApplication):
         response = self._post(url, data=payload)
         return response.json()
 
-    def retrieve_chat(
-        self, chat_id: str, account_id: str | None = None
-    ) -> dict[str, Any]:
+    def retrieve_chat(self, chat_id: str) -> dict[str, Any]:
         """
-        Retrieves a single chat's details using its Unipile or provider-specific ID. Requires an `account_id` when using a provider ID for context. This function is distinct from `list_all_chats`, which returns a collection, by targeting one specific conversation.
+        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.
 
         Args:
             chat_id: The Unipile or provider ID of the chat.
-            account_id: Mandatory if the chat_id is a provider ID. Specifies the account context.
 
         Returns:
             A dictionary containing the chat object details.
@@ -237,8 +220,8 @@ class UnipileApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats/{chat_id}"
         params: dict[str, Any] = {}
-        if account_id:
-            params["account_id"] = account_id
+        if self.account_id:
+            params["account_id"] = self.account_id
 
         response = self._get(url, params=params)
         return response.json()
@@ -250,10 +233,9 @@ class UnipileApp(APIApplication):
         after: str | None = None,  # ISO 8601 UTC datetime
         limit: int | None = None,  # 1-250
         sender_id: str | None = None,
-        account_id: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves a paginated list of messages from all chats associated with the account(s). Unlike `list_chat_messages` which targets a specific conversation, this function provides a global message view, filterable by sender, account, and date range.
+        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.
 
         Args:
             cursor: Pagination cursor.
@@ -261,7 +243,6 @@ class UnipileApp(APIApplication):
             after: Filter for items created after this ISO 8601 UTC datetime.
             limit: Number of items to return (1-250).
             sender_id: Filter messages from a specific sender.
-            account_id: Filter messages from a specific linked account.
 
         Returns:
             A dictionary containing a list of message objects and a pagination cursor.
@@ -284,8 +265,8 @@ class UnipileApp(APIApplication):
             params["limit"] = limit
         if sender_id:
             params["sender_id"] = sender_id
-        if account_id:
-            params["account_id"] = account_id
+        if self.account_id:
+            params["account_id"] = self.account_id
 
         response = self._get(url, params=params)
         return response.json()
@@ -321,33 +302,26 @@ class UnipileApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
-    def retrieve_linked_account(
-        self,
-        account_id: str,
-    ) -> dict[str, Any]:
-        """
-        Retrieves details for a specific account linked to Unipile using its ID. 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.
-
-        Args:
-            account_id: The ID of the account to retrieve.
+    # 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.
+    #     Returns:
+    #         A dictionary containing the account object details.
 
-        Raises:
-            httpx.HTTPError: If the API request fails.
+    #     Raises:
+    #         httpx.HTTPError: If the API request fails.
 
-        Tags:
-            linkedin, account, retrieve, get, unipile, api, important
-        """
-        url = f"{self.base_url}/api/v1/accounts/{account_id}"
-        response = self._get(url)
-        return response.json()
+    #     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
-        account_id: str,  # Account to perform the request from (REQUIRED)
         cursor: str | None = None,
         limit: int | None = None,  # 1-100 (spec says max 250)
         is_company: bool | None = None,
@@ -357,7 +331,6 @@ class UnipileApp(APIApplication):
 
         Args:
             identifier: The entity's provider internal ID (LinkedIn ID).
-            account_id: The ID of the Unipile account to perform the request from (REQUIRED).
             cursor: Pagination cursor.
             limit: Number of items to return (1-100, as per Unipile example, though spec allows up to 250).
             is_company: Boolean indicating if the identifier is for a company.
@@ -372,7 +345,7 @@ class UnipileApp(APIApplication):
             linkedin, post, list, user_posts, company_posts, content, api, important
         """
         url = f"{self.base_url}/api/v1/users/{identifier}/posts"
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         if cursor:
             params["cursor"] = cursor
         if limit:
@@ -383,15 +356,9 @@ class UnipileApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
-    def retrieve_own_profile(
-        self,
-        account_id: str,
-    ) -> dict[str, Any]:
+    def retrieve_own_profile(self) -> dict[str, Any]:
         """
-        Retrieves the profile details for the user associated with the specified Unipile account ID. 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.
-
-        Args:
-            account_id: The ID of the Unipile account to use for retrieving the profile (REQUIRED).
+        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.
 
         Returns:
             A dictionary containing the user's profile details.
@@ -403,21 +370,16 @@ class UnipileApp(APIApplication):
             linkedin, user, profile, me, retrieve, get, api
         """
         url = f"{self.base_url}/api/v1/users/me"
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         response = self._get(url, params=params)
         return response.json()
 
-    def retrieve_post(
-        self,
-        post_id: str,
-        account_id: str,
-    ) -> dict[str, Any]:
+    def retrieve_post(self, post_id: str) -> dict[str, Any]:
         """
-        Fetches a specific post's details by its unique ID, requiring an `account_id` for authorization. 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.
+        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.
 
         Args:
             post_id: The ID of the post to retrieve.
-            account_id: The ID of the Unipile account to perform the request from (REQUIRED).
 
         Returns:
             A dictionary containing the post details.
@@ -429,24 +391,22 @@ class UnipileApp(APIApplication):
             linkedin, post, retrieve, get, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts/{post_id}"
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         response = self._get(url, params=params)
         return response.json()
 
     def list_post_comments(
         self,
         post_id: str,
-        account_id: str,
         comment_id: str | None = None,
         cursor: str | None = None,
         limit: int | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches comments for a specific post using an `account_id` for authorization. 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'.
+        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'.
 
         Args:
             post_id: The social ID of the post.
-            account_id: The ID of the Unipile account to perform the request from (REQUIRED).
             comment_id: If provided, retrieves replies to this comment ID instead of top-level comments.
             cursor: Pagination cursor.
             limit: Number of comments to return. (OpenAPI spec shows type string, passed as string if provided).
@@ -461,7 +421,7 @@ class UnipileApp(APIApplication):
             linkedin, post, comment, list, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts/{post_id}/comments"
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
@@ -474,16 +434,14 @@ class UnipileApp(APIApplication):
 
     def create_post(
         self,
-        account_id: str,
         text: str,
         mentions: list[dict[str, Any]] | None = None,
         external_link: str | None = None,
     ) -> dict[str, Any]:
         """
-        Publishes a new top-level post from a specified 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.
+        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.
 
         Args:
-            account_id: The ID of the Unipile account that will author the post (added as query parameter).
             text: The main text content of the post.
             mentions: Optional list of dictionaries, each representing a mention.
                       Example: `[{"entity_urn": "urn:li:person:...", "start_index": 0, "end_index": 5}]`
@@ -501,7 +459,7 @@ class UnipileApp(APIApplication):
         url = f"{self.base_url}/api/v1/posts"
 
         params: dict[str, str] = {
-            "account_id": account_id,
+            "account_id": self.account_id,
             "text": text,
         }
 
@@ -516,17 +474,15 @@ class UnipileApp(APIApplication):
     def list_content_reactions(
         self,
         post_id: str,
-        account_id: str,
         comment_id: str | None = None,
         cursor: str | None = None,
         limit: int | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves a paginated list of reactions for a given post or, optionally, a specific comment. This read-only operation uses the provided `account_id` for the request, distinguishing it from the `create_reaction` function which adds new 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.
 
         Args:
             post_id: The social ID of the post.
-            account_id: The ID of the Unipile account to perform the request from .
             comment_id: If provided, retrieves reactions for this comment ID.
             cursor: Pagination cursor.
             limit: Number of reactions to return (1-100, spec max 250).
@@ -541,7 +497,7 @@ class UnipileApp(APIApplication):
             linkedin, post, reaction, list, like, content, api
         """
         url = f"{self.base_url}/api/v1/posts/{post_id}/reactions"
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         if cursor:
             params["cursor"] = cursor
         if limit:
@@ -555,7 +511,6 @@ class UnipileApp(APIApplication):
     def create_post_comment(
         self,
         post_social_id: str,
-        account_id: str,
         text: str,
         comment_id: str | None = None,  # If provided, replies to a specific comment
         mentions_body: list[dict[str, Any]] | None = None,
@@ -565,7 +520,6 @@ class UnipileApp(APIApplication):
 
         Args:
             post_social_id: The social ID of the post to comment on.
-            account_id: The ID of the Unipile account performing the comment.
             text: The text content of the comment (passed as a query parameter).
                   Supports Unipile's mention syntax like "Hey {{0}}".
             comment_id: Optional ID of a specific comment to reply to instead of commenting on the post.
@@ -582,7 +536,7 @@ class UnipileApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/posts/{post_social_id}/comments"
         params: dict[str, Any] = {
-            "account_id": account_id,
+            "account_id": self.account_id,
             "text": text,
         }
 
@@ -608,7 +562,6 @@ class UnipileApp(APIApplication):
         reaction_type: Literal[
             "like", "celebrate", "love", "insightful", "funny", "support"
         ],
-        account_id: str,
         comment_id: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -616,8 +569,7 @@ class UnipileApp(APIApplication):
 
         Args:
             post_social_id: The social ID of the post or comment to react to.
-            reaction_type: The type of reaction .
-            account_id: Account ID of the Unipile account performing the reaction.
+            reaction_type: The type of reaction. Valid values are "like", "celebrate", "love", "insightful", "funny", or "support".
             comment_id: Optional ID of a specific comment to react to instead of the post.
 
         Returns:
@@ -632,7 +584,7 @@ class UnipileApp(APIApplication):
         url = f"{self.base_url}/api/v1/posts/reaction"
 
         params: dict[str, str] = {
-            "account_id": account_id,
+            "account_id": self.account_id,
             "post_id": post_social_id,
             "reaction_type": reaction_type,
         }
@@ -652,7 +604,6 @@ class UnipileApp(APIApplication):
 
     def search(
         self,
-        account_id: str,
         category: Literal["people", "companies", "posts", "jobs"],
         cursor: str | None = None,
         limit: int | None = None,
@@ -667,13 +618,12 @@ class UnipileApp(APIApplication):
         For people, companies, and jobs, it uses the classic API.
 
         Args:
-            account_id: The ID of the Unipile account to perform the search from (REQUIRED).
-            category: Type of search to perform - "people", "companies", "posts", or "jobs".
+            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).
-            sort_by: How to sort the results (for posts and jobs).
+            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).
 
         Returns:
@@ -691,7 +641,7 @@ class UnipileApp(APIApplication):
 
         url = f"{self.base_url}/api/v1/linkedin/search"
 
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
@@ -719,19 +669,13 @@ class UnipileApp(APIApplication):
         response = self._post(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def retrieve_user_profile(
-        self,
-        identifier: str,
-        account_id: str,
-    ) -> dict[str, Any]:
+    def retrieve_user_profile(self, identifier: str) -> dict[str, Any]:
         """
-        Retrieves a specific LinkedIn user's profile using their public or internal ID, authorized via the provided `account_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.
+        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".
 
-            account_id: The ID of the Unipile account to perform the request from (REQUIRED).
-
         Returns:
             A dictionary containing the user's profile details.
 
@@ -742,7 +686,7 @@ class UnipileApp(APIApplication):
             linkedin, user, profile, retrieve, get, api, important
         """
         url = f"{self.base_url}/api/v1/users/{identifier}"
-        params: dict[str, Any] = {"account_id": account_id}
+        params: dict[str, Any] = {"account_id": self.account_id}
         response = self._get(url, params=params)
         return self._handle_response(response)
 
@@ -754,7 +698,7 @@ class UnipileApp(APIApplication):
             self.retrieve_chat,
             self.list_all_messages,
             self.list_all_accounts,
-            self.retrieve_linked_account,
+            # self.retrieve_linked_account,
             self.list_profile_posts,
             self.retrieve_own_profile,
             self.retrieve_user_profile,

{universal_mcp_applications-0.1.28 → universal_mcp_applications-0.1.30rc1}/src/universal_mcp/applications/scraper/app.py

@@ -8,7 +8,7 @@ from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
-from universal_mcp.applications.unipile import UnipileApp
+from universal_mcp.applications.linkedin import LinkedinApp
 
 
 class ScraperApp(APIApplication):
@@ -22,7 +22,7 @@ class ScraperApp(APIApplication):
         if self.integration:
             credentials = self.integration.get_credentials()
             self.account_id = credentials.get("account_id")
-            self._unipile_app = UnipileApp(integration=self.integration)
+            self._unipile_app = LinkedinApp(integration=self.integration)
         else:
             logger.warning("Integration not found")
             self.account_id = None
@@ -35,19 +35,19 @@ class ScraperApp(APIApplication):
         limit: int | None = None,
         keywords: str | None = None,
         date_posted: str | None = None,
-        sort_by: str | None = None,
-        minimum_salary_value: int | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+        minimum_salary_value: int = 40,
     ) -> dict[str, Any]:
         """
         Performs a general LinkedIn search for posts, people, companies, or jobs using keywords and various filters. This function provides broad, keyword-based discovery across the platform, distinct from other methods that retrieve content from a specific user or company profile. It supports pagination and filtering criteria.
         
         Args:
-            category: Type of search to perform - "people", "companies", "posts", or "jobs".
+            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).
-            sort_by: How to sort the results (for posts and jobs).
+            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).
         
         Returns:

universal_mcp_applications-0.1.30rc1/src/universal_mcp/applications/scraper/scraper_testers.py

@@ -0,0 +1,17 @@
+from universal_mcp.applications.scraper import ScraperApp
+
+
+from universal_mcp.agentr import AgentrClient, AgentrRegistry, AgentrIntegration
+
+client = AgentrClient(api_key="key-1f5983ba-f433-4337-b652-dc40f8712660")
+registry = AgentrRegistry(client=client)
+
+integration = AgentrIntegration(name="scraper",client=client)
+
+scraper = ScraperApp(integration=integration)
+
+if __name__ == "__main__":
+    print(scraper.linkedin_search(keywords="ai", limit=2, category="jobs"))
+    # print(scraper.linkedin_retrieve_profile(identifier="ACoAAAEkwwAB9KEc2TrQgOLEQ-vzRyZeCDyc6DQ"))
+    # print(scraper.linkedin_list_profile_posts(identifier="ACoAAAEkwwAB9KEc2TrQgOLEQ-vzRyZeCDyc6DQ", limit=2))
+    # print(scraper.linkedin_list_post_comments(post_id="urn:li:ugcPost:7386500271624896512"))

{universal_mcp_applications-0.1.28 → universal_mcp_applications-0.1.30rc1}/uv.lock

@@ -5126,7 +5126,7 @@ wheels = [
 
 [[package]]
 name = "universal-mcp-applications"
-version = "0.1.27"
+version = "0.1.29"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },