universal-mcp-applications 0.1.17__py3-none-any.whl → 0.1.33__py3-none-any.whl

universal_mcp/applications/scraper/app.py

@@ -1,13 +1,13 @@
 import os
 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
-from universal_mcp.agentr.integration import AgentrIntegration
-from universal_mcp.applications.unipile import UnipileApp
-from typing import Any, Optional
+from universal_mcp.integrations import Integration
 
 class ScraperApp(APIApplication):
     """
@@ -15,85 +15,110 @@ class ScraperApp(APIApplication):
     Provides a simplified interface for LinkedIn search operations.
     """
 
-    def __init__(self, **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", **kwargs)
+    def __init__(self, integration: Integration, **kwargs: Any) -> None:
+        super().__init__(name="scraper", integration=integration, **kwargs)
         if self.integration:
             credentials = self.integration.get_credentials()
-            api_key = credentials.get("SCRAPER_API")
-            self.account_id = credentials.get("ACCOUNT_ID")
-            self.integration = AgentrIntegration(name="unipile", api_key=api_key, base_url="https://staging-agentr-306776579029.asia-southeast1.run.app/")
-            self._unipile_app = UnipileApp(integration=self.integration)
+            self.account_id = credentials.get("account_id")
         else:
+            logger.warning("Integration not found")
             self.account_id = None
-            self._unipile_app = None
-        
-    def linkedin_post_search(
-        self,
-        category: str = "posts",
-        api: str = "classic",
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
-        keywords: Optional[str] = None,
-        sort_by: Optional[str] = None,
-        date_posted: Optional[str] = None,
-        content_type: Optional[str] = None,
-    ) -> dict[str, Any]:
+
+    @property
+    def base_url(self) -> str:
+        if not self._base_url:
+            unipile_dsn = os.getenv("UNIPILE_DSN")
+            if not unipile_dsn:
+                logger.error(
+                    "UnipileApp: UNIPILE_DSN environment variable is not set."
+                )
+                raise ValueError(
+                    "UnipileApp: UNIPILE_DSN environment variable is required."
+                )
+            self._base_url = f"https://{unipile_dsn}"
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, base_url: str) -> None:
+        self._base_url = base_url
+        logger.info(f"UnipileApp: Base URL set to {self._base_url}")
+
+    def _get_headers(self) -> dict[str, str]:
         """
-        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.
-        
+        Get the headers for Unipile API requests.
+        Overrides the base class method to use X-Api-Key.
+        """
+        if not self.integration:
+            logger.warning(
+                "UnipileApp: No integration configured, returning empty headers."
+            )
+            return {}
+
+        api_key = os.getenv("UNIPILE_API_KEY")
+        if not api_key:
+            logger.error(
+                "UnipileApp: API key not found in integration credentials for Unipile."
+            )
+            return {  # Or return minimal headers if some calls might not need auth (unlikely for Unipile)
+                "Content-Type": "application/json",
+                "Cache-Control": "no-cache",
+            }
+
+        logger.debug("UnipileApp: Using X-Api-Key for authentication.")
+        return {
+            "x-api-key": api_key,
+            "Content-Type": "application/json",
+            "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:
-            category: Type of search to perform (defaults to "posts").
-            api: Which LinkedIn API to use - "classic" or "sales_navigator".
-            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"
-        
+            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:
-            A dictionary containing search results and pagination details.
-        
+            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.
-        
-        Tags:
-            linkedin, search, posts, 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,
-        )
+        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 linkedin_list_profile_posts(
         self,
-        identifier: str,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
+        identifier: str,  # User or Company provider internal ID
+        cursor: str | None = None,
+        limit: int | None = None,  # 1-100 (spec says max 250)
+        is_company: bool | 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 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.
         
         Args:
-            identifier: The entity's provider internal ID (LinkedIn ID).starts with ACo for users, while for companies it's a series of numbers.
-            cursor: Pagination cursor for the next page of entries.
-            limit: Number of items to return (1-100, though spec allows up to 250).
+            identifier: The entity's provider internal ID (LinkedIn ID).
+            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.
         
         Returns:
             A dictionary containing a list of post objects and pagination details.
@@ -104,24 +129,24 @@ class ScraperApp(APIApplication):
         Tags:
             linkedin, post, list, user_posts, company_posts, content, api, important
         """
-        
-        return self._unipile_app.list_profile_posts(
-            identifier=identifier,
-            account_id=self.account_id,
-            cursor=cursor,
-            limit=limit,
-        )
+        url = f"{self.base_url}/api/v1/users/{identifier}/posts"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit:
+            params["limit"] = limit
+        if is_company is not None:
+            params["is_company"] = is_company
 
-    def linkedin_retrieve_profile(
-        self,
-        identifier: str,
-    ) -> dict[str, Any]:
+        response = self._get(url, params=params)
+        return response.json()
+
+    def linkedin_retrieve_profile(self, 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.
+        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.
         
         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: 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.
@@ -132,28 +157,26 @@ class ScraperApp(APIApplication):
         Tags:
             linkedin, user, profile, retrieve, get, api, important
         """
-        
-        return self._unipile_app.retrieve_user_profile(
-            identifier=identifier,
-            account_id=self.account_id,
-        )
+        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 linkedin_list_post_comments(
         self,
         post_id: str,
-        comment_id: Optional[str] = None,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
+        comment_id: str | None = None,
+        cursor: str | None = None,
+        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. 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.
         
         Args:
-            post_id: The social ID of the post. Example rn:li:activity:7342082869034393600
+            post_id: The social ID of the post.
             comment_id: If provided, retrieves replies to this comment ID instead of top-level comments.
             cursor: Pagination cursor.
-            limit: Number of comments to return.
+            limit: Number of comments to return. (OpenAPI spec shows type string, passed as string if provided).
         
         Returns:
             A dictionary containing a list of comment objects and pagination details.
@@ -164,26 +187,241 @@ class ScraperApp(APIApplication):
         Tags:
             linkedin, post, comment, list, content, api, important
         """
+        url = f"{self.base_url}/api/v1/posts/{post_id}/comments"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = str(limit)
+        if comment_id:
+            params["comment_id"] = comment_id
+
+        response = self._get(url, params=params)
+        return response.json()
+
+    def linkedin_search_people(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        location: str | None = None,
+        industry: str | None = None,
+        company: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        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.
+        
+        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 people by (e.g., "United States").
+            industry: The industry to filter people by.(e.g., "Software Development".)
+            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.
+        """
+        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": "people"}
+
+        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]
+        
+        if company:
+            company_id = self._get_search_parameter_id("COMPANY", company)
+            payload["company"] = [company_id]
         
-        return self._unipile_app.list_post_comments(
-            post_id=post_id,
-            account_id=self.account_id,
-            comment_id=comment_id,
-            cursor=cursor,
-            limit=limit,
-        )
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    def linkedin_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]:
+        """
+        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.
+        
+        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., "Software Development".)
+        
+        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 linkedin_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]:
+        """
+        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.
+        
+        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.
+            date_posted: Filter by when the post was posted.
+            sort_by: How to sort the results.
+        
+        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": "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 linkedin_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]:
+        """
+        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.
+        
+        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}
+        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):
         """
         Returns a list of available tools/functions in this application.
-        
+
         Returns:
             A list of functions that can be used as tools.
         """
         return [
-            self.linkedin_post_search,
             self.linkedin_list_profile_posts,
             self.linkedin_retrieve_profile,
             self.linkedin_list_post_comments,
-            ]
+            self.linkedin_search_people,
+            self.linkedin_search_companies,
+            self.linkedin_search_posts,
+            self.linkedin_search_jobs,
+        ]

universal_mcp/applications/semrush/README.md

@@ -42,3 +42,6 @@ This is automatically generated from OpenAPI schema for the SemrushApp API.
 | `referring_domains` | Get domains pointing to the queried domain, root domain, or URL. |
 | `referring_domains_by_country` | Get referring domain distribution by country based on IP addresses. |
 | `related_keywords` | Get extended list of related keywords, synonyms, and variations relevant to a queried term. |
+| `tlds_distribution` | Get referring domain distribution by top-level domain (e.g., .com, .org, .net). |
+| `url_organic_search_keywords` | Get keywords that bring users to a URL via Google's top 100 organic search results. |
+| `url_paid_search_keywords` | Get keywords that bring users to a URL via Google's paid search results. |

universal_mcp/applications/serpapi/README.md

@@ -9,6 +9,6 @@ This is automatically generated from OpenAPI schema for the SerpapiApp API.
 
 | Tool | Description |
 |------|-------------|
-| `search` | Performs a search using the SerpApi service and returns formatted search results. |
-| `google_maps_search` | Performs a Google Maps search using the SerpApi service and returns formatted search results. |
-| `get_google_maps_reviews` | Retrieves Google Maps reviews for a specific place using the SerpApi service. |
+| `web_search` | Performs a general web search via SerpApi, defaulting to the 'google_light' engine. It accepts custom parameters, retrieves organic results, and formats them into a string with titles, links, and snippets. It also handles API authentication and raises `NotAuthorizedError` for credential-related issues. |
+| `google_maps_search` | Executes a Google Maps search via SerpApi using a query, coordinates, or place ID. It enhances the results by adding a `google_maps_url` to each location, distinguishing it from `get_google_maps_reviews` which retrieves reviews for a known place. |
+| `get_google_maps_reviews` | Fetches Google Maps reviews for a specific location via SerpApi using its unique `data_id`. This function uses the `google_maps_reviews` engine, unlike `google_maps_search` which finds locations. Results can be returned in a specified language, defaulting to English. |

universal_mcp/applications/serpapi/app.py

@@ -2,12 +2,12 @@ from typing import Any  # For type hinting
 
 import httpx
 from loguru import logger
-
-from serpapi import SerpApiClient as SerpApiSearch  # Added SerpApiError
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.exceptions import NotAuthorizedError  # For auth errors
 from universal_mcp.integrations import Integration  # For integration type hint
 
+from serpapi import SerpApiClient as SerpApiSearch  # Added SerpApiError
+
 
 class SerpapiApp(APIApplication):
     def __init__(self, integration: Integration | None = None, **kwargs: Any) -> None:
@@ -78,17 +78,17 @@ class SerpapiApp(APIApplication):
     async def web_search(self, params: dict[str, Any] | None = None) -> str:
         """
         Performs a general web search via SerpApi, defaulting to the 'google_light' engine. It accepts custom parameters, retrieves organic results, and formats them into a string with titles, links, and snippets. It also handles API authentication and raises `NotAuthorizedError` for credential-related issues.
-        
+
         Args:
             params: Dictionary of engine-specific parameters (e.g., {'q': 'Coffee', 'engine': 'google_light', 'location': 'Austin, TX'}). Defaults to None.
-        
+
         Returns:
             A formatted string containing search results with titles, links, and snippets, or an error message if the search fails.
-        
+
         Raises:
             NotAuthorizedError: If the API key cannot be retrieved or is invalid/rejected by SerpApi.
             Exception: For other unexpected errors during the search process. (Specific HTTP errors or SerpApiErrors are caught and returned as strings or raise NotAuthorizedError).
-        
+
         Tags:
             search, async, web-scraping, api, serpapi, important
         """
@@ -194,19 +194,19 @@ class SerpapiApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Executes a Google Maps search via SerpApi using a query, coordinates, or place ID. It enhances the results by adding a `google_maps_url` to each location, distinguishing it from `get_google_maps_reviews` which retrieves reviews for a known place.
-        
+
         Args:
             q (string, optional): The search query for Google Maps (e.g., "Coffee", "Restaurants", "Gas stations").
             ll (string, optional): Latitude and longitude with zoom level in format "@lat,lng,zoom" (e.g., "@40.7455096,-74.0083012,14z"). The zoom attribute ranges from 3z (map completely zoomed out) to 21z (map completely zoomed in). Results are not guaranteed to be within the requested geographic location.
             place_id (string, optional): The unique reference to a place in Google Maps. Place IDs are available for most locations, including businesses, landmarks, parks, and intersections. You can find the place_id using our Google Maps API. place_id can be used without any other optional parameter. place_id and data_cid can't be used together.
-        
+
         Returns:
             dict[str, Any]: Formatted Google Maps search results with place names, addresses, ratings, and other details.
-        
+
         Raises:
             ValueError: Raised when required parameters are missing.
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-        
+
         Tags:
             google-maps, search, location, places, important
         """
@@ -249,18 +249,18 @@ class SerpapiApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Fetches Google Maps reviews for a specific location via SerpApi using its unique `data_id`. This function uses the `google_maps_reviews` engine, unlike `google_maps_search` which finds locations. Results can be returned in a specified language, defaulting to English.
-        
+
         Args:
             data_id (string): The data ID of the place to get reviews for (e.g., "0x89c259af336b3341:0xa4969e07ce3108de").
             hl (string, optional): Language parameter for the search results. Defaults to "en".
-        
+
         Returns:
             dict[str, Any]: Google Maps reviews data with ratings, comments, and other review details.
-        
+
         Raises:
             ValueError: Raised when required parameters are missing.
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-        
+
         Tags:
             google-maps, reviews, ratings, places, important
         """

universal_mcp/applications/sharepoint/README.md

@@ -0,0 +1,19 @@
+# SharePoint Application
+
+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.
+
+## Available Tools
+
+-   `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.