universal-mcp-applications 0.1.27rc2__py3-none-any.whl → 0.1.28__py3-none-any.whl

universal_mcp/applications/google_gemini/app.py

@@ -62,9 +62,9 @@ class GoogleGeminiApp(APIApplication):
     async def generate_image(
         self,
         prompt: Annotated[str, "The prompt to generate image from"],
-        images: Annotated[list[str], "The reference images path"] | None = None,
+        images: Annotated[list[str], "The reference image URLs"] | None = None, 
         model: str = "gemini-2.5-flash-image-preview",
-    ) -> list:
+    ) -> dict:
         """
         Generates an image based on a text prompt and an optional reference image using the Google Gemini model.
         This tool is ideal for creating visual content or modifying existing images based on natural language descriptions.
@@ -72,7 +72,7 @@ class GoogleGeminiApp(APIApplication):
 
         Args:
             prompt (str): The descriptive text prompt to guide the image generation. For example: "A futuristic city at sunset with flying cars."
-            images (list[str], optional): An optional list of URL to a reference image. These images will be used as a basis for the generation.
+            images (list[str], optional): An optional list of URLs to reference images. These images will be used as a basis for the generation.
             model (str, optional): The Gemini model to use for image generation. Defaults to "gemini-2.5-flash-image-preview".
 
         Returns:

universal_mcp/applications/onedrive/README.md

@@ -1,10 +1,10 @@
-# OneDriveApp MCP Server
+# OnedriveApp MCP Server
 
-An MCP Server for the OneDriveApp API.
+An MCP Server for the OnedriveApp API.
 
 ## 🛠️ Tool List
 
-This is automatically generated from OpenAPI schema for the OneDriveApp API.
+This is automatically generated from OpenAPI schema for the OnedriveApp API.
 
 
 | Tool | Description |
@@ -21,4 +21,4 @@ This is automatically generated from OpenAPI schema for the OneDriveApp API.
 | `list_files` | Retrieves a list of files within a specified OneDrive folder, defaulting to the root. Unlike `_list_drive_items` which fetches all items, this function filters the results to exclusively return items identified as files, excluding any subdirectories. |
 | `create_folder_and_list` | Performs a composite action: creates a new folder, then lists all items (files and folders) within that parent directory. This confirms creation by returning the parent's updated contents, distinct from `create_folder` which only returns the new folder's metadata. |
 | `upload_text_file` | Creates and uploads a new file to OneDrive directly from a string of text content. Unlike `upload_file`, which requires a local file path, this function is specifically for creating a text file from in-memory string data, with a customizable name and destination folder. |
-| `get_document_content` | Retrieves the content of a file specified by its ID. It automatically detects if the file is text or binary; text content is returned as a string, while binary content is returned base64-encoded. This differs from `download_file`, which only provides a URL. |
+| `get_document_content` | Retrieves the content of a specific file by its item ID and returns it directly as base64-encoded data. This function is distinct from `download_file`, which only provides a temporary URL for the content, and from `get_item_metadata`, which returns file attributes without the content itself. The function fetches the content by following the file's pre-authenticated download URL. |

universal_mcp/applications/onedrive/app.py

@@ -2,6 +2,7 @@ import base64
 import os
 from typing import Any
 
+from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -271,13 +272,17 @@ class OnedriveApp(APIApplication):
 
     def get_document_content(self, item_id: str) -> dict[str, Any]:
         """
-        Retrieves the content of a file specified by its ID. It automatically detects if the file is text or binary; text content is returned as a string, while binary content is returned base64-encoded. This differs from `download_file`, which only provides a URL.
+        Retrieves the content of a specific file by its item ID and returns it directly as base64-encoded data. This function is distinct from `download_file`, which only provides a temporary URL for the content, and from `get_item_metadata`, which returns file attributes without the content itself. The function fetches the content by following the file's pre-authenticated download URL.
 
         Args:
             item_id (str): The ID of the file.
 
         Returns:
-            A dictionary containing the file content. For text files, content is string. For binary, it's base64 encoded.
+            dict[str, Any]: A dictionary containing the file details:
+                - 'type' (str): The general type of the file (e.g., "image", "audio", "video", "file").
+                - 'data' (str): The base64 encoded content of the file.
+                - 'mime_type' (str): The MIME type of the file.
+                - 'file_name' (str): The name of the file.
 
         Tags:
             get, content, read, file, important
@@ -290,34 +295,29 @@ class OnedriveApp(APIApplication):
         if not file_metadata:
             raise ValueError(f"Item with ID '{item_id}' is not a file.")
 
-        file_mime_type = file_metadata.get("mimeType", "")
+        file_mime_type = file_metadata.get("mimeType", "application/octet-stream")
+        file_name = metadata.get("name")
 
-        url = f"{self.base_url}/me/drive/items/{item_id}/content"
-        response = self._get(url)
-
-        if response.status_code >= 400:
-            # Try to handle as JSON error response from Graph API
-            return self._handle_response(response)
+        download_url = metadata.get("@microsoft.graph.downloadUrl")
+        if not download_url:
+            logger.error(f"Could not find @microsoft.graph.downloadUrl in metadata for item {item_id}")
+            raise ValueError("Could not retrieve download URL for the item.")
 
-        content = response.content
+        response = self._get(download_url)
 
-        is_text = file_mime_type.startswith("text/") or any(t in file_mime_type for t in ["json", "xml", "csv", "javascript", "html"])
+        response.raise_for_status()
 
-        content_dict = {}
-        if is_text:
-            try:
-                content_dict["content"] = content.decode("utf-8")
-            except UnicodeDecodeError:
-                is_text = False
+        content = response.content
 
-        if not is_text:
-            content_dict["content_base64"] = base64.b64encode(content).decode("ascii")
+        attachment_type = file_mime_type.split("/")[0] if "/" in file_mime_type else "file"
+        if attachment_type not in ["image", "audio", "video", "text"]:
+            attachment_type = "file"
 
         return {
-            "name": metadata.get("name"),
-            "content_type": "text" if is_text else "binary",
-            **content_dict,
-            "size": len(content),
+            "type": attachment_type,
+            "data": content,
+            "mime_type": file_mime_type,
+            "file_name": file_name,
         }
 
     def list_tools(self):

universal_mcp/applications/scraper/app.py

@@ -2,7 +2,7 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-from typing import Any
+from typing import Any, Literal
 
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
@@ -18,14 +18,6 @@ class ScraperApp(APIApplication):
     """
 
     def __init__(self, integration: Integration, **kwargs: Any) -> None:
-        """
-        Initialize the ScraperApp.
-
-        Args:
-            integration: The integration configuration containing credentials and other settings.
-                         It is expected that the integration provides the necessary credentials
-                         for LinkedIn API access.
-        """
         super().__init__(name="scraper", integration=integration, **kwargs)
         if self.integration:
             credentials = self.integration.get_credentials()
@@ -36,50 +28,46 @@ class ScraperApp(APIApplication):
             self.account_id = None
             self._unipile_app = None
 
-    def linkedin_post_search(
+    def linkedin_search(
         self,
-        category: str = "posts",
-        api: str = "classic",
+        category: Literal["people", "companies", "posts", "jobs"],
         cursor: str | None = None,
         limit: int | None = None,
         keywords: str | None = None,
-        sort_by: str | None = None,
         date_posted: str | None = None,
-        content_type: str | None = None,
+        sort_by: str | None = None,
+        minimum_salary_value: int | None = None,
     ) -> dict[str, Any]:
         """
-        Performs a general LinkedIn search for posts using keywords and filters like date and content type. It supports pagination and can utilize either the 'classic' or 'sales_navigator' API, searching broadly across the platform rather than fetching posts from a specific user's profile.
-
+        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 (defaults to "posts").
-            api: Which LinkedIn API to use - "classic" or "sales_navigator".
+            category: Type of search to perform - "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.
-            sort_by: How to sort the results, e.g., "relevance" or "date".
-            date_posted: Filter posts by when they were posted.
-            content_type: Filter by the type of content in the post. Example: "videos", "images", "live_videos", "collaborative_articles", "documents"
-
+            date_posted: Filter by when the post was posted (posts only).
+            sort_by: How to sort the results (for posts and jobs).
+            minimum_salary_value: The minimum salary to filter for (jobs only).
+        
         Returns:
             A dictionary containing search results and pagination details.
-
+        
         Raises:
             httpx.HTTPError: If the API request fails.
-
+        
         Tags:
-            linkedin, search, posts, api, scrapper, important
+            linkedin, search, posts, people, companies, api, scrapper, important
         """
-
         return self._unipile_app.search(
             account_id=self.account_id,
             category=category,
-            api=api,
             cursor=cursor,
             limit=limit,
             keywords=keywords,
-            sort_by=sort_by,
             date_posted=date_posted,
-            content_type=content_type,
+            sort_by=sort_by,
+            minimum_salary_value=minimum_salary_value,
         )
 
     def linkedin_list_profile_posts(
@@ -89,19 +77,19 @@ class ScraperApp(APIApplication):
         limit: int | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches a paginated list of all LinkedIn posts from a specific user or company profile using their unique identifier. This function retrieves content directly from a profile, unlike `linkedin_post_search` which finds posts across LinkedIn based on keywords and other filters.
-
+        Fetches a paginated list of all posts from a specific user or company profile using their unique identifier. This function retrieves content directly from a single profile, unlike the broader, keyword-based `linkedin_search` which searches across the entire LinkedIn platform.
+        
         Args:
-            identifier: The entity's provider internal ID (LinkedIn ID).starts with ACo for users, while for companies it's a series of numbers.
+            identifier: The entity's provider internal ID (LinkedIn ID).starts with ACo for users, while for companies it's a series of numbers. You can get it in the results of linkedin_search.
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (1-100, though spec allows up to 250).
-
+        
         Returns:
             A dictionary containing a list of post objects and pagination details.
-
+        
         Raises:
             httpx.HTTPError: If the API request fails.
-
+        
         Tags:
             linkedin, post, list, user_posts, company_posts, content, api, important
         """
@@ -118,18 +106,17 @@ class ScraperApp(APIApplication):
         identifier: str,
     ) -> dict[str, Any]:
         """
-        Retrieves a specific LinkedIn user's profile by their unique identifier, which can be an internal provider ID or a public username. This function simplifies data access by delegating the actual profile retrieval request to the integrated Unipile application, distinct from functions that list posts or comments.
-
+        Retrieves a specific LinkedIn user's profile using their unique identifier (e.g., public username). Unlike other methods that list posts or comments, this function focuses on fetching the user's core profile data by delegating the request to the integrated Unipile application.
+        
         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".
-
+            identifier: Use the id from linkedin_search results. It starts with ACo for users and is a series of numbers for companies.
+        
         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
         """
@@ -147,20 +134,20 @@ class ScraperApp(APIApplication):
         limit: int | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches comments for a specified LinkedIn post. If a `comment_id` is provided, it retrieves replies to that comment instead of top-level comments. This function supports pagination and specifically targets comments, unlike others in the class that search for or list entire posts.
-
+        Fetches a paginated list of comments for a specified LinkedIn post. Providing a `comment_id` retrieves replies to that specific comment instead of top-level ones. This function exclusively targets post interactions, differentiating it from others that list posts or retrieve entire profiles.
+        
         Args:
-            post_id: The social ID of the post. Example rn:li:activity:7342082869034393600
+            post_id: The social ID of the post. Example urn:li:ugcPost:7386500271624896512
             comment_id: If provided, retrieves replies to this comment ID instead of top-level comments.
             cursor: Pagination cursor.
             limit: Number of comments to return.
-
+        
         Returns:
             A dictionary containing a list of comment objects and pagination details.
-
+        
         Raises:
             httpx.HTTPError: If the API request fails.
-
+        
         Tags:
             linkedin, post, comment, list, content, api, important
         """
@@ -173,223 +160,6 @@ class ScraperApp(APIApplication):
             limit=limit,
         )
 
-    def linkedin_people_search(
-        self,
-        cursor: str | None = None,
-        limit: int | None = None,
-        keywords: str | None = None,
-        last_viewed_at: int | None = None,
-        saved_search_id: str | None = None,
-        recent_search_id: str | None = None,
-        location: dict[str, Any] | None = None,
-        location_by_postal_code: dict[str, Any] | None = None,
-        industry: dict[str, Any] | None = None,
-        first_name: str | None = None,
-        last_name: str | None = None,
-        tenure: list[dict[str, Any]] | None = None,
-        groups: list[str] | None = None,
-        school: dict[str, Any] | None = None,
-        profile_language: list[str] | None = None,
-        company: dict[str, Any] | None = None,
-        company_headcount: list[dict[str, Any]] | None = None,
-        company_type: list[str] | None = None,
-        company_location: dict[str, Any] | None = None,
-        tenure_at_company: list[dict[str, Any]] | None = None,
-        past_company: dict[str, Any] | None = None,
-        function: dict[str, Any] | None = None,
-        role: dict[str, Any] | None = None,
-        tenure_at_role: list[dict[str, Any]] | None = None,
-        seniority: dict[str, Any] | None = None,
-        past_role: dict[str, Any] | None = None,
-        following_your_company: bool | None = None,
-        viewed_your_profile_recently: bool | None = None,
-        network_distance: list[str] | None = None,
-        connections_of: list[str] | None = None,
-        past_colleague: bool | None = None,
-        shared_experiences: bool | None = None,
-        changed_jobs: bool | None = None,
-        posted_on_linkedin: bool | None = None,
-        mentionned_in_news: bool | None = None,
-        persona: list[str] | None = None,
-        account_lists: dict[str, Any] | None = None,
-        lead_lists: dict[str, Any] | None = None,
-        viewed_profile_recently: bool | None = None,
-        messaged_recently: bool | None = None,
-        include_saved_leads: bool | None = None,
-        include_saved_accounts: bool | None = None,
-    ) -> dict[str, Any]:
-        """
-        Performs a comprehensive LinkedIn Sales Navigator people search with advanced targeting options.
-        This function provides access to LinkedIn's Sales Navigator search capabilities for finding people
-        with precise filters including experience, company details, education, and relationship criteria.
-
-        Args:
-            cursor: Pagination cursor for the next page of entries.
-            limit: Number of items to return.
-            keywords: LinkedIn native filter: KEYWORDS.
-            last_viewed_at: Unix timestamp for saved search filtering.
-            saved_search_id: ID of saved search (overrides other parameters).
-            recent_search_id: ID of recent search (overrides other parameters).
-            location: LinkedIn native filter: GEOGRAPHY. Example: {"include": ["San Francisco Bay Area", "New York City Area"]}
-            location_by_postal_code: Location filter by postal code. Example: {"postal_code": "94105", "radius": "25"}
-            industry: LinkedIn native filter: INDUSTRY. Example: {"include": ["Information Technology and Services", "Financial Services"]}
-            first_name: LinkedIn native filter: FIRST NAME. Example: "John"
-            last_name: LinkedIn native filter: LAST NAME. Example: "Smith"
-            tenure: LinkedIn native filter: YEARS OF EXPERIENCE. Example: [{"min": 5, "max": 10}]
-            groups: LinkedIn native filter: GROUPS. Example: ["group_id_1", "group_id_2"]
-            school: LinkedIn native filter: SCHOOL. Example: {"include": ["Stanford University", "Harvard University"]}
-            profile_language: ISO 639-1 language codes, LinkedIn native filter: PROFILE LANGUAGE. Example: ["en", "es"]
-            company: LinkedIn native filter: CURRENT COMPANY. Example: {"include": ["Google", "Microsoft", "Apple"]}
-            company_headcount: LinkedIn native filter: COMPANY HEADCOUNT. Example: [{"min": 100, "max": 1000}]
-            company_type: LinkedIn native filter: COMPANY TYPE. Example: ["Public Company", "Privately Held"]
-            company_location: LinkedIn native filter: COMPANY HEADQUARTERS LOCATION. Example: {"include": ["San Francisco", "Seattle"]}
-            tenure_at_company: LinkedIn native filter: YEARS IN CURRENT COMPANY. Example: [{"min": 2, "max": 5}]
-            past_company: LinkedIn native filter: PAST COMPANY. Example: {"include": ["Facebook", "Amazon"]}
-            function: LinkedIn native filter: FUNCTION. Example: {"include": ["Engineering", "Sales", "Marketing"]}
-            role: LinkedIn native filter: CURRENT JOB TITLE. Example: {"include": ["Software Engineer", "Product Manager"]}
-            tenure_at_role: LinkedIn native filter: YEARS IN CURRENT POSITION. Example: [{"min": 1, "max": 3}]
-            seniority: LinkedIn native filter: SENIORITY LEVEL. Example: {"include": ["Senior", "Director", "VP"]}
-            past_role: LinkedIn native filter: PAST JOB TITLE. Example: {"include": ["Senior Developer", "Team Lead"]}
-            following_your_company: LinkedIn native filter: FOLLOWING YOUR COMPANY. Example: True
-            viewed_your_profile_recently: LinkedIn native filter: VIEWED YOUR PROFILE RECENTLY. Example: True
-            network_distance: First, second, third+ degree or GROUP, LinkedIn native filter: CONNECTION. Example: ["1st", "2nd"]
-            connections_of: LinkedIn native filter: CONNECTIONS OF. Example: ["person_id_1", "person_id_2"]
-            past_colleague: LinkedIn native filter: PAST COLLEAGUE. Example: True
-            shared_experiences: LinkedIn native filter: SHARED EXPERIENCES. Example: True
-            changed_jobs: LinkedIn native filter: CHANGED JOBS. Example: True
-            posted_on_linkedin: LinkedIn native filter: POSTED ON LINKEDIN. Example: True
-            mentionned_in_news: LinkedIn native filter: MENTIONNED IN NEWS. Example: True
-            persona: LinkedIn native filter: PERSONA. Example: ["persona_id_1", "persona_id_2"]
-            account_lists: LinkedIn native filter: ACCOUNT LISTS. Example: {"include": ["list_id_1"]}
-            lead_lists: LinkedIn native filter: LEAD LISTS. Example: {"include": ["lead_list_id_1"]}
-            viewed_profile_recently: LinkedIn native filter: PEOPLE YOU INTERACTED WITH / VIEWED PROFILE. Example: True
-            messaged_recently: LinkedIn native filter: PEOPLE YOU INTERACTED WITH / MESSAGED. Example: True
-            include_saved_leads: LinkedIn native filter: SAVED LEADS AND ACCOUNTS / ALL MY SAVED LEADS. Example: True
-            include_saved_accounts: LinkedIn native filter: SAVED LEADS AND ACCOUNTS / ALL MY SAVED ACCOUNTS. Example: True
-
-        Returns:
-            A dictionary containing search results and pagination details.
-
-        Raises:
-            httpx.HTTPError: If the API request fails.
-
-        Tags:
-            linkedin, sales_navigator, people, search, advanced, scraper, api, important
-        """
-        return self._unipile_app.people_search(
-            account_id=self.account_id,
-            cursor=cursor,
-            limit=limit,
-            keywords=keywords,
-            last_viewed_at=last_viewed_at,
-            saved_search_id=saved_search_id,
-            recent_search_id=recent_search_id,
-            location=location,
-            location_by_postal_code=location_by_postal_code,
-            industry=industry,
-            first_name=first_name,
-            last_name=last_name,
-            tenure=tenure,
-            groups=groups,
-            school=school,
-            profile_language=profile_language,
-            company=company,
-            company_headcount=company_headcount,
-            company_type=company_type,
-            company_location=company_location,
-            tenure_at_company=tenure_at_company,
-            past_company=past_company,
-            function=function,
-            role=role,
-            tenure_at_role=tenure_at_role,
-            seniority=seniority,
-            past_role=past_role,
-            following_your_company=following_your_company,
-            viewed_your_profile_recently=viewed_your_profile_recently,
-            network_distance=network_distance,
-            connections_of=connections_of,
-            past_colleague=past_colleague,
-            shared_experiences=shared_experiences,
-            changed_jobs=changed_jobs,
-            posted_on_linkedin=posted_on_linkedin,
-            mentionned_in_news=mentionned_in_news,
-            persona=persona,
-            account_lists=account_lists,
-            lead_lists=lead_lists,
-            viewed_profile_recently=viewed_profile_recently,
-            messaged_recently=messaged_recently,
-            include_saved_leads=include_saved_leads,
-            include_saved_accounts=include_saved_accounts,
-        )
-
-    def linkedin_company_search(
-        self,
-        cursor: str | None = None,
-        limit: int | None = None,
-        keywords: str | None = None,
-        last_viewed_at: int | None = None,
-        saved_search_id: str | None = None,
-        recent_search_id: str | None = None,
-        location: dict[str, Any] | None = None,
-        location_by_postal_code: dict[str, Any] | None = None,
-        industry: dict[str, Any] | None = None,
-        company_headcount: list[dict[str, Any]] | None = None,
-        company_type: list[str] | None = None,
-        company_location: dict[str, Any] | None = None,
-        following_your_company: bool | None = None,
-        account_lists: dict[str, Any] | None = None,
-        include_saved_accounts: bool | None = None,
-    ) -> dict[str, Any]:
-        """
-        Performs a comprehensive LinkedIn Sales Navigator company search with advanced targeting options.
-        This function provides access to LinkedIn's Sales Navigator search capabilities for finding companies
-        with precise filters including size, location, industry, and relationship criteria.
-
-        Args:
-            cursor: Pagination cursor for the next page of entries.
-            limit: Number of items to return.
-            keywords: LinkedIn native filter: KEYWORDS. Example: "fintech startup"
-            last_viewed_at: Unix timestamp for saved search filtering.
-            saved_search_id: ID of saved search (overrides other parameters).
-            recent_search_id: ID of recent search (overrides other parameters).
-            location: LinkedIn native filter: GEOGRAPHY. Example: {"include": ["San Francisco Bay Area", "New York City Area"]}
-            location_by_postal_code: Location filter by postal code. Example: {"postal_code": "94105", "radius": "25"}
-            industry: LinkedIn native filter: INDUSTRY. Example: {"include": ["Information Technology and Services", "Financial Services"]}
-            company_headcount: LinkedIn native filter: COMPANY HEADCOUNT. Example: [{"min": 10, "max": 100}]
-            company_type: LinkedIn native filter: COMPANY TYPE. Example: ["Public Company", "Privately Held", "Startup"]
-            company_location: LinkedIn native filter: COMPANY HEADQUARTERS LOCATION. Example: {"include": ["San Francisco", "Seattle", "Austin"]}
-            following_your_company: LinkedIn native filter: FOLLOWING YOUR COMPANY. Example: True
-            account_lists: LinkedIn native filter: ACCOUNT LISTS. Example: {"include": ["account_list_id_1"]}
-            include_saved_accounts: LinkedIn native filter: SAVED LEADS AND ACCOUNTS / ALL MY SAVED ACCOUNTS. Example: True
-
-        Returns:
-            A dictionary containing search results and pagination details.
-
-        Raises:
-            httpx.HTTPError: If the API request fails.
-
-        Tags:
-            linkedin, sales_navigator, companies, search, advanced, scraper, api, important
-        """
-        return self._unipile_app.company_search(
-            account_id=self.account_id,
-            cursor=cursor,
-            limit=limit,
-            keywords=keywords,
-            last_viewed_at=last_viewed_at,
-            saved_search_id=saved_search_id,
-            recent_search_id=recent_search_id,
-            location=location,
-            location_by_postal_code=location_by_postal_code,
-            industry=industry,
-            company_headcount=company_headcount,
-            company_type=company_type,
-            company_location=company_location,
-            following_your_company=following_your_company,
-            account_lists=account_lists,
-            include_saved_accounts=include_saved_accounts,
-        )
-
     def list_tools(self):
         """
         Returns a list of available tools/functions in this application.
@@ -398,10 +168,8 @@ class ScraperApp(APIApplication):
             A list of functions that can be used as tools.
         """
         return [
-            self.linkedin_post_search,
+            self.linkedin_search,
             self.linkedin_list_profile_posts,
             self.linkedin_retrieve_profile,
             self.linkedin_list_post_comments,
-            self.linkedin_people_search,
-            self.linkedin_company_search,
         ]

universal_mcp/applications/sharepoint/README.md

@@ -1,17 +1,19 @@
-# SharepointApp MCP Server
+# SharePoint Application
 
-An MCP Server for the SharepointApp API.
+This application provides tools for interacting with the Microsoft SharePoint API via Microsoft Graph. It allows you to manage files, folders, and retrieve information about your SharePoint drive.
 
-## 🛠️ Tool List
+## Available Tools
 
-This is automatically generated from OpenAPI schema for the SharepointApp API.
-
-
-| Tool | Description |
-|------|-------------|
-| `list_folders` | Retrieves a list of immediate subfolder names within a specified SharePoint directory. If no path is provided, it defaults to the root drive. This function is distinct from `list_files`, as it exclusively lists directories, not files. |
-| `create_folder_and_list` | Creates a new folder with a given name inside a specified parent directory (or the root). It then returns an updated list of all folder names within that same directory, effectively confirming that the creation operation was successful. |
-| `list_files` | Retrieves metadata for all files in a specified folder. For each file, it returns key details like name, URL, size, and timestamps. This function exclusively lists file properties, distinguishing it from `list_folders` (which lists directories) and `get_document_content` (which retrieves file content). |
-| `upload_text_file` | Uploads string content to create a new file in a specified SharePoint folder. To confirm the operation, it returns an updated list of all files and their metadata from that directory, including the newly created file. |
-| `get_document_content` | Retrieves a file's content from a specified SharePoint path. It returns a dictionary containing the file's name and size, decoding text files as a string and Base64-encoding binary files. Unlike `list_files`, which only fetches metadata, this function provides the actual file content. |
-| `delete_document` | Permanently deletes a specified file from a SharePoint drive using its full path. This is the sole destructive file operation, contrasting with functions that read or create files. It returns `True` on successful deletion and raises an exception on failure, such as if the file is not found. |
+-   `get_my_profile`: Fetches the profile for the currently authenticated user.
+-   `get_drive_info`: Fetches high-level information about the user's SharePoint drive.
+-   `search_files`: Searches for files and folders in the user's SharePoint.
+-   `get_item_metadata`: Fetches metadata for a specific file or folder.
+-   `create_folder`: Creates a new folder.
+-   `delete_item`: Deletes a file or folder.
+-   `download_file`: Retrieves a download URL for a file.
+-   `upload_file`: Uploads a local file.
+-   `list_folders`: Lists all folders in a specified directory.
+-   `list_files`: Lists all files in a specified directory.
+-   `create_folder_and_list`: Creates a folder and then lists the contents of the parent directory.
+-   `upload_text_file`: Uploads content from a string to a new text file.
+-   `get_document_content`: Retrieves the content of a file.