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

universal_mcp/applications/domain-checker/README.md

@@ -0,0 +1,13 @@
+# DomainCheckerApp MCP Server
+
+An MCP Server for the DomainCheckerApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the DomainCheckerApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `check_domain_tool` | Checks if a domain is available for registration by querying DNS records and RDAP data. |
+| `check_tlds_tool` | Checks a keyword across multiple top-level domains (TLDs) to find available domain names. |

universal_mcp/applications/domain-checker/__init__.py

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

universal_mcp/applications/domain-checker/app.py

@@ -0,0 +1,265 @@
+import logging
+import sys
+from typing import Any
+
+import dns.resolver
+import requests
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stderr)],
+)
+
+logger = logging.getLogger("domain_checker")
+
+# Constants
+RDAP_BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json"
+USER_AGENT = "DomainCheckerBot/1.0"
+
+# Top TLDs to check
+TOP_TLDS = [
+    "com",
+    "net",
+    "org",
+    "io",
+    "co",
+    "app",
+    "dev",
+    "ai",
+    "me",
+    "info",
+    "xyz",
+    "online",
+    "site",
+    "tech",
+]
+
+
+class DomainCheckerApp(APIApplication):
+    """
+    Base class for Universal MCP Applications.
+    """
+
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        super().__init__(name="domain-checker", integration=integration, **kwargs)
+
+    async def get_rdap_data(self, domain: str) -> dict[str, Any] | None:
+        """Get RDAP data for a domain"""
+        try:
+            # Special case for .ch and .li domains
+            tld = domain.split(".")[-1].lower()
+            if tld in ["ch", "li"]:
+                rdap_url = f"https://rdap.nic.{tld}/domain/{domain}"
+            # Use common RDAP servers for known TLDs
+            elif tld in ["com", "net"]:
+                rdap_url = f"https://rdap.verisign.com/{tld}/v1/domain/{domain}"
+            elif tld == "org":
+                rdap_url = (
+                    f"https://rdap.publicinterestregistry.org/rdap/domain/{domain}"
+                )
+            else:
+                rdap_url = f"https://rdap.org/domain/{domain}"
+
+            headers = {"Accept": "application/rdap+json", "User-Agent": USER_AGENT}
+
+            response = requests.get(rdap_url, headers=headers, timeout=5)
+            if response.status_code == 200:
+                return response.json()
+            return None
+        except Exception as e:
+            logger.error(f"RDAP error for {domain}: {e}")
+            return None
+
+    async def check_dns(self, domain: str) -> bool:
+        """Check if a domain has DNS records"""
+        try:
+            dns.resolver.resolve(domain, "A")
+            return True
+        except:
+            try:
+                dns.resolver.resolve(domain, "NS")
+                return True
+            except:
+                return False
+
+    async def check_domain_tool(self, domain: str) -> dict[str, Any]:
+        """
+        Checks if a domain is available for registration by querying DNS records and RDAP data.
+
+        This method performs a comprehensive domain availability check by first checking DNS records
+        and then querying RDAP (Registration Data Access Protocol) servers for detailed registration
+        information. It provides detailed information about registered domains including registrar,
+        registration date, and expiration date.
+
+        Args:
+            domain: String representing the domain name to check (e.g., "example.com")
+
+        Returns:
+            Dictionary containing domain availability information with the following keys:
+            - domain: The domain name that was checked
+            - status: "Registered" or "Available"
+            - registrar: Name of the registrar (or None/Unknown if not registered)
+            - registration_date: Domain registration date (or None/Unknown)
+            - expiration_date: Domain expiration date (or None/Unknown)
+            - has_dns: Boolean indicating if DNS records exist
+            - rdap_data_available: Boolean indicating if RDAP data was retrieved
+            - note: Additional information when needed
+
+        Raises:
+            DNSException: When DNS resolution fails due to network issues or invalid domain format
+            RequestException: When RDAP queries fail due to network issues or server errors
+            ValueError: When the domain parameter is empty or contains invalid characters
+
+        Tags:
+            domain, availability, registration, dns, rdap, important
+        """
+        logger.info(f"Checking domain: {domain}")
+
+        # First check DNS
+        has_dns = await self.check_dns(domain)
+
+        if has_dns:
+            # Domain exists, get RDAP data if possible
+            rdap_data = await self.get_rdap_data(domain)
+
+            if rdap_data:
+                # Extract data from RDAP
+                registrar = "Unknown"
+                reg_date = "Unknown"
+                exp_date = "Unknown"
+
+                # Extract registrar
+                entities = rdap_data.get("entities", [])
+                for entity in entities:
+                    if "registrar" in entity.get("roles", []):
+                        vcard = entity.get("vcardArray", [])
+                        if len(vcard) > 1 and isinstance(vcard[1], list):
+                            for entry in vcard[1]:
+                                if entry[0] in ["fn", "org"] and len(entry) > 3:
+                                    registrar = entry[3]
+                                    break
+
+                # Extract dates
+                events = rdap_data.get("events", [])
+                for event in events:
+                    if event.get("eventAction") == "registration":
+                        reg_date = event.get("eventDate", "Unknown")
+                    elif event.get("eventAction") == "expiration":
+                        exp_date = event.get("eventDate", "Unknown")
+
+                return {
+                    "domain": domain,
+                    "status": "Registered",
+                    "registrar": registrar,
+                    "registration_date": reg_date,
+                    "expiration_date": exp_date,
+                    "has_dns": True,
+                    "rdap_data_available": True,
+                }
+            else:
+                return {
+                    "domain": domain,
+                    "status": "Registered",
+                    "registrar": "Unknown",
+                    "registration_date": "Unknown",
+                    "expiration_date": "Unknown",
+                    "has_dns": True,
+                    "rdap_data_available": False,
+                    "note": "Domain has DNS records but RDAP data couldn't be retrieved",
+                }
+
+        # Try RDAP one more time even if DNS not found
+        rdap_data = await self.get_rdap_data(domain)
+        if rdap_data:
+            return {
+                "domain": domain,
+                "status": "Registered",
+                "registrar": "Unknown",
+                "registration_date": "Unknown",
+                "expiration_date": "Unknown",
+                "has_dns": False,
+                "rdap_data_available": True,
+                "note": "Domain found in RDAP registry",
+            }
+
+        # If we get here, the domain is likely available
+        return {
+            "domain": domain,
+            "status": "Available",
+            "registrar": None,
+            "registration_date": None,
+            "expiration_date": None,
+            "has_dns": False,
+            "rdap_data_available": False,
+            "note": "No DNS records or RDAP data found",
+        }
+
+    async def check_tlds_tool(self, keyword: str) -> dict[str, Any]:
+        """
+        Checks a keyword across multiple top-level domains (TLDs) to find available domain names.
+
+        This method systematically checks a given keyword across 14 popular TLDs including .com, .net,
+        .org, .io, .co, .app, .dev, .ai, .me, .info, .xyz, .online, .site, and .tech. It performs
+        DNS lookups and RDAP queries to determine domain availability and provides a comprehensive
+        report of available and taken domains.
+
+        Args:
+            keyword: String representing the keyword to check across TLDs (e.g., "myapp")
+
+        Returns:
+            Dictionary containing TLD availability information with the following keys:
+            - keyword: The keyword that was checked
+            - tlds_checked: Number of TLDs checked (14)
+            - available_count: Number of available domains found
+            - taken_count: Number of taken domains found
+            - available_domains: List of available domain names
+            - taken_domains: List of taken domain names
+            - tlds_checked_list: Complete list of TLDs that were checked
+
+        Raises:
+            DNSException: When DNS resolution fails due to network issues or invalid domain format
+            RequestException: When RDAP queries fail due to network issues or server errors
+            ValueError: When the keyword parameter is empty or contains invalid characters
+
+        Tags:
+            tld, keyword, domain-search, availability, bulk-check, important
+        """
+        logger.info(f"Checking keyword: {keyword} across TLDs")
+
+        available = []
+        taken = []
+
+        # Check each TLD in sequence
+        for tld in TOP_TLDS:
+            domain = f"{keyword}.{tld}"
+            has_dns = await self.check_dns(domain)
+
+            if not has_dns:
+                # Double-check with RDAP if no DNS
+                rdap_data = await self.get_rdap_data(domain)
+                if not rdap_data:
+                    available.append(domain)
+                else:
+                    taken.append(domain)
+            else:
+                taken.append(domain)
+
+        return {
+            "keyword": keyword,
+            "tlds_checked": len(TOP_TLDS),
+            "available_count": len(available),
+            "taken_count": len(taken),
+            "available_domains": available,
+            "taken_domains": taken,
+            "tlds_checked_list": TOP_TLDS,
+        }
+
+    def list_tools(self):
+        """
+        Lists the available tools (methods) for this application.
+        """
+        return [self.check_domain_tool, self.check_tlds_tool]

universal_mcp/applications/e2b/README.md

@@ -0,0 +1,12 @@
+# E2b MCP Server
+
+An MCP Server for the E2b API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the E2b API.
+
+
+| Tool | Description |
+|------|-------------|
+| `execute_python_code` | Executes Python code in a sandbox environment and returns the formatted output |

universal_mcp/applications/e2b/__init__.py

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

universal_mcp/applications/e2b/app.py

@@ -0,0 +1,187 @@
+from typing import Annotated, Any
+
+from loguru import logger
+
+try:
+    from e2b_code_interpreter import Sandbox
+
+except ImportError:
+    Sandbox = None
+    logger.error(
+        "Failed to import E2B Sandbox. Please ensure 'e2b_code_interpreter' is installed."
+    )
+
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.exceptions import NotAuthorizedError, ToolError
+from universal_mcp.integrations import Integration
+
+
+class E2bApp(APIApplication):
+    """
+    Application for interacting with the E2B (Code Interpreter Sandbox) platform.
+    Provides tools to execute Python code in a sandboxed environment.
+    Authentication is handled by the configured Integration, fetching the API key.
+    """
+
+    def __init__(self, integration: Integration | None = None, **kwargs: Any) -> None:
+        super().__init__(name="e2b", integration=integration, **kwargs)
+        self._e2b_api_key: str | None = None  # Cache for the API key
+        if Sandbox is None:
+            logger.warning(
+                "E2B Sandbox SDK is not available. E2B tools will not function."
+            )
+
+    @property
+    def e2b_api_key(self) -> str:
+        """
+        Retrieves and caches the E2B API key from the integration.
+        Raises NotAuthorizedError if the key cannot be obtained.
+        """
+        if self._e2b_api_key is None:
+            if not self.integration:
+                logger.error("E2B App: Integration not configured.")
+                raise NotAuthorizedError(
+                    "Integration not configured for E2B App. Cannot retrieve API key."
+                )
+
+            try:
+                credentials = self.integration.get_credentials()
+            except NotAuthorizedError as e:
+                logger.error(
+                    f"E2B App: Authorization error when fetching credentials: {e.message}"
+                )
+                raise  # Re-raise the original NotAuthorizedError
+            except Exception as e:
+                logger.error(
+                    f"E2B App: Unexpected error when fetching credentials: {e}",
+                    exc_info=True,
+                )
+                raise NotAuthorizedError(f"Failed to get E2B credentials: {e}")
+
+            api_key = (
+                credentials.get("api_key")
+                or credentials.get("API_KEY")  # Check common variations
+                or credentials.get("apiKey")
+            )
+
+            if not api_key:
+                logger.error("E2B App: API key not found in credentials.")
+                action_message = "API key for E2B is missing. Please ensure it's set in the store via MCP frontend or configuration."
+                if hasattr(self.integration, "authorize") and callable(
+                    self.integration.authorize
+                ):
+                    try:
+                        auth_details = self.integration.authorize()
+                        if isinstance(auth_details, str):
+                            action_message = auth_details
+                        elif isinstance(auth_details, dict) and "url" in auth_details:
+                            action_message = (
+                                f"Please authorize via: {auth_details['url']}"
+                            )
+                        elif (
+                            isinstance(auth_details, dict) and "message" in auth_details
+                        ):
+                            action_message = auth_details["message"]
+                    except Exception as auth_e:
+                        logger.warning(
+                            f"Could not retrieve specific authorization action for E2B: {auth_e}"
+                        )
+                raise NotAuthorizedError(action_message)
+
+            self._e2b_api_key = api_key
+            logger.info("E2B API Key successfully retrieved and cached.")
+        return self._e2b_api_key
+
+    def _format_execution_output(self, logs: Any) -> str:
+        """Helper function to format the E2B execution logs nicely."""
+        output_parts = []
+
+        # Safely access stdout and stderr
+        stdout_log = getattr(logs, "stdout", [])
+        stderr_log = getattr(logs, "stderr", [])
+
+        if stdout_log:
+            stdout_content = "".join(stdout_log).strip()
+            if stdout_content:
+                output_parts.append(f"{stdout_content}")
+
+        if stderr_log:
+            stderr_content = "".join(stderr_log).strip()
+            if stderr_content:
+                output_parts.append(f"--- ERROR ---\n{stderr_content}")
+
+        if not output_parts:
+            return "Execution finished with no output (stdout/stderr)."
+        return "\n\n".join(output_parts)
+
+    def execute_python_code(
+        self, code: Annotated[str, "The Python code to execute."]
+    ) -> str:
+        """
+        Executes Python code in a sandbox environment and returns the formatted output.
+
+        Args:
+            code: String containing the Python code to be executed in the sandbox.
+
+        Returns:
+            A string containing the formatted execution output/logs from running the code.
+
+        Raises:
+            ToolError: When there are issues with sandbox initialization or code execution,
+                       or if the E2B SDK is not installed.
+            NotAuthorizedError: When API key authentication fails during sandbox setup.
+            ValueError: When provided code string is empty or invalid.
+
+        Tags:
+            execute, sandbox, code-execution, security, important
+        """
+        if Sandbox is None:
+            logger.error(
+                "E2B Sandbox SDK is not available. Cannot execute_python_code."
+            )
+            raise ToolError(
+                "E2B Sandbox SDK (e2b_code_interpreter) is not installed or failed to import."
+            )
+
+        if not code or not isinstance(code, str):
+            raise ValueError("Provided code must be a non-empty string.")
+
+        logger.info("Attempting to execute Python code in E2B Sandbox.")
+        try:
+            current_api_key = self.e2b_api_key
+
+            with Sandbox(api_key=current_api_key) as sandbox:
+                logger.info(
+                    f"E2B Sandbox (ID: {sandbox.sandbox_id}) initialized. Running code."
+                )
+                execution = sandbox.run_code(
+                    code=code
+                )  # run_python is the method in e2b-code-interpreter
+                result = self._format_execution_output(
+                    execution.logs
+                )  # execution_result directly has logs
+                logger.info("E2B code execution successful.")
+                return result
+        except NotAuthorizedError:  # Re-raise if caught from self.e2b_api_key
+            raise
+        except Exception as e:
+            if (
+                "authentication" in str(e).lower()
+                or "api key" in str(e).lower()
+                or "401" in str(e)
+                or "unauthorized" in str(e).lower()
+            ):
+                logger.error(
+                    f"E2B authentication/authorization error: {e}", exc_info=True
+                )
+                raise NotAuthorizedError(
+                    f"E2B authentication failed or access denied: {e}"
+                )
+            logger.error(f"Error during E2B code execution: {e}", exc_info=True)
+            raise ToolError(f"E2B code execution failed: {e}")
+
+    def list_tools(self) -> list[callable]:
+        """Lists the tools available from the E2bApp."""
+        return [
+            self.execute_python_code,
+        ]

universal_mcp/applications/elevenlabs/README.md

@@ -0,0 +1,88 @@
+# ElevenlabsApp MCP Server
+
+An MCP Server for the ElevenlabsApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the ElevenlabsApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `get_generated_items` | Retrieves historical data based on specified parameters, including page size and voice ID, using the "GET" method at the "/v1/history" endpoint. |
+| `get_history_item_by_id` | Retrieves a specific history item by its identifier using the API defined at "/v1/history/{history_item_id}" with the GET method. |
+| `delete_history_item` | Deletes a specific history item identified by its ID using the DELETE method. |
+| `get_audio_from_history_item` | Retrieves audio data for a specific history item identified by `{history_item_id}` using the `GET` method at the `/v1/history/{history_item_id}/audio` endpoint. |
+| `download_history_items` | Initiates a historical data download process and returns a success status upon completion. |
+| `delete_sample` | Deletes a specific voice sample identified by the `sample_id` from a voice with the given `voice_id` using the DELETE method. |
+| `get_audio_from_sample` | Retrieves the audio file for a specific sample associated with a given voice using the specified voice_id and sample_id. |
+| `convert` | Converts text into speech using a specified voice, allowing for optimization of streaming latency and selection of output format. |
+| `text_to_speech_with_timestamps` | Generates speech from text with precise character or word-level timing information using the specified voice, supporting audio-text synchronization through timestamps. |
+| `convert_as_stream` | Converts text to speech stream using the specified voice ID with configurable latency and output format. |
+| `stream_text_with_timestamps` | Converts text to speech using the specified voice ID, streaming the audio output with timestamps. |
+| `voice_generation_parameters` | Retrieves the parameters required for generating voice using the specified API endpoint. |
+| `generate_arandom_voice` | Generates an audio file by converting text into speech using a specified voice, allowing for customizable voice selection and text input. |
+| `create_voice_model` | Generates a custom voice using the provided parameters via the "/v1/voice-generation/create-voice" endpoint by sending a POST request, allowing users to create unique voice models. |
+| `create_previews` | Generates a voice preview from a given text prompt using the ElevenLabs API. |
+| `create_voice_from_preview` | Creates a new voice entry in the voice library using a generated preview ID and returns voice details. |
+| `get_user_subscription_info` | Retrieves the user's subscription details from the API. |
+| `get_user_info` | Retrieves user information from the API. |
+| `get_voices` | Retrieves a list of voices using the "GET" method at the "/v1/voices" API endpoint. |
+| `get_default_voice_settings` | Retrieves the default voice settings using the "GET" method at the "/v1/voices/settings/default" endpoint. |
+| `get_voice_settings` | Retrieves voice settings for a specific voice identified by `{voice_id}` using the "GET" method, returning the current configuration for that voice. |
+| `get_voice` | Retrieves the details of a specific voice by its ID using the "GET" method at the "/v1/voices/{voice_id}" endpoint. |
+| `delete_voice` | Deletes a voice with the specified ID using the DELETE method at the "/v1/voices/{voice_id}" endpoint. |
+| `edit_voice_settings` | Updates voice settings for a specified voice ID and returns a success status. |
+| `add_voice` | Adds a new voice entry to the voices collection using the provided data. |
+| `edit_voice` | Updates the specified voice by ID using a POST request and returns a success status upon completion. |
+| `add_sharing_voice` | Adds a voice associated with a public user ID and voice ID using the specified API endpoint. |
+| `get_shared_voices` | Retrieves a list of shared voices filtered by parameters like gender and language, with pagination support via page_size. |
+| `get_similar_library_voices` | Generates a list of similar voices using the POST method at the "/v1/similar-voices" endpoint. |
+| `get_aprofile_page` | Retrieves a unified customer profile by handle and returns the associated attributes, identifiers, and traits. |
+| `get_projects` | Retrieves a list of projects using the API defined at the "/v1/projects" endpoint via the GET method. |
+| `add_project` | Creates a new project and returns a status message. |
+| `get_project_by_id` | Retrieves information for a specific project identified by `{project_id}` using the API endpoint at "/v1/projects/{project_id}" via the GET method. |
+| `edit_basic_project_info` | Creates a new project resource by sending data to the specified project identifier using the POST method at the "/v1/projects/{project_id}" endpoint. |
+| `delete_project` | Deletes the specified project and returns a success status upon completion. |
+| `convert_project` | Converts a specified project identified by project_id and returns the conversion result. |
+| `get_project_snapshots` | Retrieves a list of snapshots associated with a specified project. |
+| `streams_archive_with_project_audio` | Archives a project snapshot using the specified project ID and snapshot ID and returns a success status. |
+| `add_chapter_to_aproject` | Adds a new chapter to a specified project using the provided project identifier and returns a success status upon completion. |
+| `update_project_pronunciations` | Updates pronunciation dictionaries for a specified project using the POST method, returning a successful status message upon completion. |
+| `get_chapters` | Retrieves a chapter for a specified project by ID using the GET method. |
+| `get_chapter_by_id` | Retrieves a specific chapter within a project identified by project_id and chapter_id. |
+| `delete_chapter` | Deletes a specific chapter within a project using the "DELETE" method. |
+| `convert_chapter` | Converts a chapter in a project using the POST method and returns a response upon successful conversion. |
+| `get_chapter_snapshots` | Retrieves a snapshot for a specific chapter within a project using the provided project and chapter IDs. |
+| `stream_chapter_audio` | Streams data from a specific chapter snapshot in a project using the API and returns a response indicating success. |
+| `dub_avideo_or_an_audio_file` | Initiates a dubbing process and returns a status message using the API defined at the "/v1/dubbing" endpoint via the POST method. |
+| `get_dubbing_project_metadata` | Retrieves the details of a specific dubbing job using the provided dubbing ID. |
+| `delete_dubbing_project` | Deletes a dubbing project with the specified ID and returns a success status upon completion. |
+| `get_transcript_for_dub` | Retrieves the transcript for a specific dubbing task in the requested language using the "GET" method. |
+| `get_models` | Retrieves a list of models using the GET method at the "/v1/models" endpoint. |
+| `post_audio_native` | Processes audio data using the audio-native API and returns a response. |
+| `get_characters_usage_metrics` | Retrieves character statistics within a specified time frame using the start and end Unix timestamps provided in the query parameters. |
+| `add_apronunciation_dictionary` | Creates a pronunciation dictionary from a lexicon file and returns its ID and metadata. |
+| `add_rules_to_dictionary` | Adds pronunciation rules to a specific pronunciation dictionary identified by its ID using the POST method. |
+| `remove_pronunciation_rules` | Removes specified pronunciation rules from a pronunciation dictionary using a POST request. |
+| `get_dictionary_version_file` | Retrieves and downloads a specific version of a pronunciation dictionary file using its dictionary ID and version ID. |
+| `get_pronunciation_dictionary` | Retrieves a specific pronunciation dictionary by its ID using the "GET" method from the "/v1/pronunciation-dictionaries/{pronunciation_dictionary_id}" endpoint. |
+| `get_pronunciation_dictionaries` | Retrieves a list of pronunciation dictionaries using the GET method at the "/v1/pronunciation-dictionaries" endpoint, allowing users to specify the number of items per page via the "page_size" query parameter. |
+| `invite_user` | Invites a user to join a workspace by sending an invitation, allowing them to access the specified workspace upon acceptance. |
+| `delete_existing_invitation` | Deletes a workspace invite and returns a success response upon completion. |
+| `update_member` | Adds members to a workspace and returns the updated member list upon success. |
+| `get_signed_url` | Generates a signed URL for initiating a conversation with a specific conversational AI agent, identified by the provided `agent_id`, using the ElevenLabs API. |
+| `create_agent` | Creates a conversational AI agent with specified configuration settings and returns the agent details. |
+| `get_agent` | Retrieves information about a specific conversational AI agent by its unique identifier using the GET method at the "/v1/convai/agents/{agent_id}" API endpoint. |
+| `delete_agent` | Deletes a specified Conversational AI agent using the DELETE method. |
+| `patches_an_agent_settings` | Updates an existing conversational AI agent's settings using the specified agent ID, allowing changes to properties such as the agent's name and tool configurations. |
+| `get_agent_widget_config` | Retrieves and configures the Convai widget for the specified agent, but the provided details do not specify the exact functionality of this specific endpoint, suggesting it may relate to integrating or customizing Convai's character interaction capabilities. |
+| `get_shareable_agent_link` | Retrieves and establishes a link for a Convai agent using the specified agent ID, facilitating integration or connectivity operations. |
+| `post_agent_avatar` | Creates and configures a Convai avatar for a specific agent using the POST method, though the exact details of this endpoint are not provided in the available documentation. |
+| `get_agent_knowledge_base` | Retrieves specific documentation for a knowledge base associated with an agent in Convai. |
+| `add_agent_secret` | Adds a secret to a specified conversational AI agent through the API and returns a status confirmation. |
+| `add_to_agent_sknowledge_base` | Adds new content to an agent's knowledge base by uploading a file or resource, which can be used to enhance the agent's conversational capabilities. |
+| `get_agents_page` | Retrieves a list of conversational AI agents available in the Convai system. |
+| `get_conversations` | Retrieves conversation history for a specified agent ID. |
+| `get_conversation_details` | Retrieves and formats the details of a specific conversation based on the provided conversation ID. |
+| `get_conversation_audio` | Retrieves the audio from a specific conversation using the ElevenLabs Conversational AI API. |

universal_mcp/applications/elevenlabs/__init__.py

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