deepctl-cmd-mcp 0.1.0__tar.gz

deepctl_cmd_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: deepctl-cmd-mcp
+Version: 0.1.0
+Summary: MCP server command for deepctl to interact with Deepgram's AI assistant service
+Author-email: Deepgram <devrel@deepgram.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: deepctl-core>=0.1.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: rich>=13.9.4
+Requires-Dist: click>=8.1.7
+Requires-Dist: pydantic>=2.10.1
+Requires-Dist: httpx>=0.28.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: pytest-cov>=6.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"
+Requires-Dist: mypy>=1.13.0; extra == "dev"
+Requires-Dist: ruff>=0.8.1; extra == "dev"
+
+# deepctl-cmd-mcp
+
+This package provides two ways to interact with Deepgram's AI assistant:
+
+1. **MCP Server**: Run an MCP server that exposes Deepgram's AI assistant tools
+2. **Python Client**: Standalone Python client for interacting with Deepgram's AI API
+
+## Installation
+
+This package is installed as part of the main deepctl CLI.

deepctl_cmd_mcp-0.1.0/README.md

@@ -0,0 +1,10 @@
+# deepctl-cmd-mcp
+
+This package provides two ways to interact with Deepgram's AI assistant:
+
+1. **MCP Server**: Run an MCP server that exposes Deepgram's AI assistant tools
+2. **Python Client**: Standalone Python client for interacting with Deepgram's AI API
+
+## Installation
+
+This package is installed as part of the main deepctl CLI.

deepctl_cmd_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deepctl-cmd-mcp"
+version = "0.1.0"
+description = "MCP server command for deepctl to interact with Deepgram's AI assistant service"
+readme = "README.md"
+authors = [{ name = "Deepgram", email = "devrel@deepgram.com" }]
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = [
+    "deepctl-core>=0.1.0",
+    "mcp>=1.0.0",
+    "rich>=13.9.4",
+    "click>=8.1.7",
+    "pydantic>=2.10.1",
+    "httpx>=0.28.1",
+]
+
+[project.entry-points."deepctl.commands"]
+mcp = "deepctl_cmd_mcp.command:McpCommand"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.3",
+    "pytest-asyncio>=0.24.0",
+    "pytest-cov>=6.0.0",
+    "pytest-mock>=3.14.0",
+    "mypy>=1.13.0",
+    "ruff>=0.8.1",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["deepctl_cmd_mcp*"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "B", "Q"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true

deepctl_cmd_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp/__init__.py

@@ -0,0 +1,14 @@
+"""MCP server command for deepctl."""
+
+from .command import McpCommand
+from .gnosis import GnosisClient, GnosisRequest, GnosisResponse
+from .models import MCPServerResult, TransportType
+
+__all__ = [
+    "McpCommand",
+    "GnosisClient",
+    "GnosisRequest",
+    "GnosisResponse",
+    "MCPServerResult",
+    "TransportType",
+]

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp/__main__.py

@@ -0,0 +1,8 @@
+"""Main entry point for running gnosis module directly."""
+
+from .gnosis import main
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp/command.py

@@ -0,0 +1,387 @@
+"""MCP server command for deepctl."""
+
+import os
+from typing import Any, Dict, List, Optional
+
+from deepctl_core import AuthManager, BaseCommand, Config, DeepgramClient
+from mcp.server.fastmcp import Context, FastMCP
+from rich.console import Console
+
+from .gnosis import GnosisClient
+from .models import MCPServerResult, TransportType
+
+console = Console()
+
+
+class McpCommand(BaseCommand):
+    """MCP server command for interacting with Deepgram's AI assistant."""
+
+    name = "mcp"
+    help = "Run an MCP server that connects to Deepgram's AI assistant service"
+    short_help = "Run MCP server for Deepgram AI"
+
+    # MCP doesn't require existing auth to start, but can use it
+    requires_auth = False
+    requires_project = False
+    ci_friendly = True
+
+    def get_arguments(self) -> List[Dict[str, Any]]:
+        """Get command arguments and options."""
+        return [
+            {
+                "names": ["--transport", "-t"],
+                "help": (
+                    "Transport mode: stdio (default), sse, "
+                    "or streamable-http"
+                ),
+                "type": str,
+                "default": "stdio",
+                "required": False,
+                "is_option": True,
+            },
+            {
+                "names": ["--port", "-p"],
+                "help": "Port number for HTTP server (default: 8000)",
+                "type": int,
+                "default": 8000,
+                "required": False,
+                "is_option": True,
+            },
+            {
+                "names": ["--host"],
+                "help": "Host address for HTTP server (default: 127.0.0.1)",
+                "type": str,
+                "default": "127.0.0.1",
+                "required": False,
+                "is_option": True,
+            },
+            {
+                "names": ["--api-key"],
+                "help": (
+                    "Override API key for Deepgram AI service (falls back to "
+                    "profile or DEEPGRAM_API_KEY env var)"
+                ),
+                "type": str,
+                "required": False,
+                "is_option": True,
+            },
+            {
+                "names": ["--gnosis-url"],
+                "help": "Base URL for Deepgram AI service",
+                "type": str,
+                "default": "https://gnosis.deepgram.com",
+                "required": False,
+                "is_option": True,
+            },
+            {
+                "names": ["--debug"],
+                "help": "Enable debug logging",
+                "is_flag": True,
+                "is_option": True,
+            },
+        ]
+
+    def handle(
+        self,
+        config: Config,
+        auth_manager: AuthManager,
+        client: DeepgramClient,
+        **kwargs: Any,
+    ) -> Any:
+        """Handle MCP server command."""
+        transport = kwargs.get("transport", "stdio").lower()
+        port = kwargs.get("port", 8000)
+        host = kwargs.get("host", "127.0.0.1")
+        gnosis_api_key = kwargs.get("api_key") or os.getenv("DEEPGRAM_API_KEY")
+        # Fallback to stored credentials if no key provided
+        if not gnosis_api_key:
+            gnosis_api_key = auth_manager.get_api_key()
+        gnosis_url = kwargs.get("gnosis_url", "https://gnosis.deepgram.com")
+        debug = kwargs.get("debug", False)
+
+        # Validate transport type
+        valid_transports = ["stdio", "sse", "streamable-http"]
+        if transport not in valid_transports:
+            console.print(
+                f"[red]Invalid transport type:[/red] {transport}. "
+                f"Must be one of: {', '.join(valid_transports)}"
+            )
+            return MCPServerResult(
+                status="error", message=f"Invalid transport type: {transport}"
+            )
+
+        # Store configuration in environment for the MCP server
+        if isinstance(gnosis_api_key, str) and gnosis_api_key:
+            # Expose for child processes / downstream code
+            os.environ["DEEPGRAM_API_KEY"] = gnosis_api_key
+        os.environ["DEEPGRAM_GNOSIS_URL"] = gnosis_url
+        if debug:
+            os.environ["DEEPGRAM_MCP_DEBUG"] = "1"
+
+        # Create and run the MCP server
+        mcp_server = create_mcp_server()
+
+        try:
+            if transport == "stdio":
+                console.print(
+                    "[blue]Starting MCP server in stdio mode...[/blue]"
+                )
+                mcp_server.run()
+            elif transport == "sse":
+                console.print(
+                    f"[blue]Starting MCP SSE server on {host}:{port}...[/blue]"
+                )
+                mcp_server.run(transport="sse")
+            elif transport == "streamable-http":
+                console.print(
+                    f"[blue]Starting MCP Streamable HTTP server on "
+                    f"{host}:{port}...[/blue]"
+                )
+                mcp_server.run(transport="streamable-http")
+
+            return MCPServerResult(
+                status="success",
+                message="MCP server stopped",
+                transport=TransportType(transport.replace("-", "")),
+                port=port if transport != "stdio" else None,
+                host=host if transport != "stdio" else None,
+            )
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]MCP server stopped by user[/yellow]")
+            return MCPServerResult(
+                status="cancelled",
+                message="MCP server stopped by user",
+                transport=TransportType(transport.replace("-", "")),
+                port=port if transport != "stdio" else None,
+                host=host if transport != "stdio" else None,
+            )
+        except Exception as e:
+            console.print(f"[red]Error running MCP server:[/red] {e}")
+            return MCPServerResult(
+                status="error",
+                message=str(e),
+                transport=TransportType(transport.replace("-", "")),
+                port=port if transport != "stdio" else None,
+                host=host if transport != "stdio" else None,
+            )
+
+
+def create_mcp_server() -> FastMCP:
+    """Create the MCP server with Deepgram AI assistant tools."""
+    # Create FastMCP instance
+    mcp = FastMCP("Deepgram AI Assistant")
+
+    # Get configuration from environment
+    gnosis_api_key = os.getenv("DEEPGRAM_API_KEY")
+    gnosis_url = os.getenv(
+        "DEEPGRAM_GNOSIS_URL", "https://gnosis.deepgram.com"
+    )
+    debug = os.getenv("DEEPGRAM_MCP_DEBUG", "").lower() in ("1", "true", "yes")
+
+    # Debug logging to diagnose URL issue
+    if debug:
+        import sys
+
+        print(
+            f"[DEBUG] DEEPGRAM_GNOSIS_URL from env: {gnosis_url}",
+            file=sys.stderr,
+        )
+
+    # Create a shared Gnosis client instance
+    try:
+        gnosis_client = GnosisClient(
+            api_key=gnosis_api_key,
+            base_url=gnosis_url,
+            debug=debug,
+        )
+    except ValueError:
+        # Client will be None if no API key is available
+        gnosis_client = None
+
+    @mcp.tool()
+    async def ask_question(question: str, ctx: Context[Any, Any, Any]) -> str:
+        """Ask questions about Deepgram products and services.
+
+        This is the **catch-all** helper for natural-language queries about
+        anything related to Deepgram. Use it for general product or feature
+        questions, onboarding advice ("How do I get started with live
+        transcription?"), pricing, SDK capabilities, best practices, model
+        details, or any other information request that does **not** obviously
+        belong to one of the specialised tools below.
+
+        Example questions that should route to this tool:
+        • "What is the difference between pre-recorded and live transcription?"
+        • "Does Deepgram offer speaker diarization?"
+        • "How accurate is Nova-2 on telephone audio?"
+
+        Args:
+            question: The question to ask about Deepgram (products, services,
+                SDKs, APIs, pricing, etc.)
+            ctx: MCP context used by FastMCP
+        """
+        if not gnosis_client:
+            return (
+                "Error: Deepgram API key not configured. Please set "
+                "DEEPGRAM_API_KEY, use the --api-key flag, or store a "
+                "credential."
+            )
+
+        if debug:
+            await ctx.info(f"Asking question: {question}")
+
+        try:
+            return await gnosis_client.ask_question(
+                question,
+                system_prompt=(
+                    "You are a helpful assistant that answers questions about "
+                    "Deepgram products and services."
+                ),
+            )
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    @mcp.tool()
+    async def check_api_spec(
+        api_type: str = "rest",
+        endpoint: str = "",
+        ctx: Optional[Context[Any, Any, Any]] = None,
+    ) -> str:
+        """Retrieve Deepgram **API reference** details.
+
+        Use this tool when the user explicitly asks for endpoint specifics,
+        HTTP verbs, WebSocket event schemas, request/response bodies,
+        authentication headers, rate limits, or error codes—anything that
+        belongs to the formal API specification.
+
+        Example queries that should trigger this tool:
+        • "Show me the REST API spec for /v1/listen"
+        • "What fields does the WebSocket start message accept?"
+        • "Which status codes can the Transcription API return?"
+
+        Args:
+            api_type: Either 'rest' or 'websocket'. Defaults to 'rest'.
+            endpoint: Optional specific endpoint path (e.g., "/v1/listen").
+                Leave blank for an overview.
+            ctx: MCP context
+        """
+        if not gnosis_client:
+            return (
+                "Error: Deepgram API key not configured. Please set "
+                "DEEPGRAM_API_KEY, use the --api-key flag, or store a "
+                "credential."
+            )
+
+        if ctx and debug:
+            await ctx.info(f"Checking API spec: {api_type} {endpoint}")
+
+        prompt = (
+            f"Provide the API specification for Deepgram's {api_type.upper()} "
+        )
+        if endpoint:
+            prompt += f"endpoint: {endpoint}"
+        else:
+            prompt += "endpoints"
+
+        try:
+            return await gnosis_client.ask_question(
+                prompt,
+                system_prompt=(
+                    "You are a technical assistant that provides detailed API "
+                    "specifications for Deepgram."
+                ),
+            )
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    @mcp.tool()
+    async def get_code_example(
+        language: str,
+        use_case: str,
+        ctx: Optional[Context[Any, Any, Any]] = None,
+    ) -> str:
+        """Return **ready-to-run code samples** that integrate Deepgram.
+
+        Use this when the user asks for sample code or snippets in a particular
+        language or SDK, e.g. "Give me a Python example for real-time
+        transcription" or "Show a JavaScript snippet for batch processing".
+
+        Args:
+            language: Target programming language (python, javascript,
+                typescript, go, java, csharp, etc.)
+            use_case: The scenario for the snippet (e.g., "real-time
+                transcription", "batch processing").
+            ctx: MCP context
+        """
+        if not gnosis_client:
+            return (
+                "Error: Deepgram API key not configured. Please set "
+                "DEEPGRAM_API_KEY, use the --api-key flag, or store a "
+                "credential."
+            )
+
+        if ctx and debug:
+            await ctx.info(f"Getting code example: {language} for {use_case}")
+
+        prompt = f"Provide a {language} code example for: {use_case}"
+
+        try:
+            return await gnosis_client.ask_question(
+                prompt,
+                system_prompt=(
+                    f"You are a code assistant that provides {language} "
+                    f"code examples for Deepgram."
+                ),
+            )
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    @mcp.tool()
+    async def search_docs(
+        query: str,
+        category: str = "all",
+        ctx: Optional[Context[Any, Any, Any]] = None,
+    ) -> str:
+        """Keyword search across official Deepgram documentation.
+
+        Ideal for requests that mention "documentation", "docs", "guide",
+        or when the user wants a how-to or tutorial section. The search can
+        be narrowed to specific categories like guides, SDK references, or
+        API reference.
+
+        Example queries:
+        • "Find the docs page about audio formats"
+        • "Search the guides for diarization"
+
+        Args:
+            query: Search terms to look for.
+            category: One of 'guides', 'api-reference', 'sdks', or 'all'.
+                Defaults to 'all'.
+            ctx: MCP context
+        """
+        if not gnosis_client:
+            return (
+                "Error: Deepgram API key not configured. Please set "
+                "DEEPGRAM_API_KEY, use the --api-key flag, or store a "
+                "credential."
+            )
+
+        if ctx and debug:
+            await ctx.info(f"Searching docs: {query} in {category}")
+
+        search_prompt = f"Search Deepgram documentation for: {query}"
+        if category != "all":
+            search_prompt += f" (category: {category})"
+
+        try:
+            return await gnosis_client.ask_question(
+                search_prompt,
+                system_prompt=(
+                    "You are a documentation assistant that helps find "
+                    "relevant information in Deepgram's docs."
+                ),
+            )
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    return mcp

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp/gnosis.py

@@ -0,0 +1,372 @@
+"""Gnosis API client for Deepgram's AI assistant service."""
+
+import asyncio
+import json
+import os
+import sys
+from typing import Any, Dict, List, Optional
+
+import httpx
+from pydantic import BaseModel, Field
+
+
+class GnosisRequest(BaseModel):
+    """Request model for Gnosis API."""
+
+    messages: List[Dict[str, str]] = Field(
+        ..., description="List of messages in the conversation"
+    )
+    model: str = Field(
+        default="deepgram", description="Model to use for generation"
+    )
+    temperature: float = Field(
+        default=0.7, description="Temperature for generation"
+    )
+    max_tokens: Optional[int] = Field(
+        default=None, description="Maximum tokens to generate"
+    )
+
+
+class GnosisResponse(BaseModel):
+    """Response model from Gnosis API."""
+
+    choices: List[Dict[str, Any]] = Field(
+        default_factory=list, description="Response choices"
+    )
+    usage: Optional[Dict[str, Any]] = Field(
+        default=None, description="Token usage information"
+    )
+    model: Optional[str] = Field(default=None, description="Model used")
+    id: Optional[str] = Field(default=None, description="Response ID")
+    created: Optional[int] = Field(
+        default=None, description="Creation timestamp"
+    )
+
+
+class GnosisClient:
+    """Client for interacting with Deepgram's Gnosis API."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://gnosis.deepgram.com",
+        timeout: float = 30.0,
+        debug: bool = False,
+    ):
+        """Initialize the Gnosis client.
+
+        Args:
+            api_key: Deepgram API key. If not provided, will check
+                DEEPGRAM_API_KEY env var.
+            base_url: Base URL for Gnosis API.
+            timeout: Request timeout in seconds.
+            debug: Enable debug logging.
+        """
+        self.api_key = api_key or os.getenv("DEEPGRAM_API_KEY")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.debug = debug
+
+        if not self.api_key:
+            raise ValueError(
+                "API key is required. Provide it as a parameter or set "
+                "DEEPGRAM_API_KEY environment variable."
+            )
+
+    async def call(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = "deepgram",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+    ) -> str:
+        """Make a request to the Gnosis API.
+
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+                keys.
+            model: Model to use for generation.
+            temperature: Temperature for generation.
+            max_tokens: Maximum tokens to generate.
+
+        Returns:
+            The response content from Gnosis.
+
+        Raises:
+            httpx.HTTPStatusError: If the API returns an error status.
+            Exception: For other errors during the request.
+        """
+        request = GnosisRequest(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+
+        if self.debug:
+            print(
+                f"[DEBUG] Request: {request.model_dump_json()}",
+                file=sys.stderr,
+            )
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/v1/chat/completions",
+                    json=request.model_dump(),
+                    headers={
+                        "Authorization": f"token {self.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    timeout=self.timeout,
+                )
+                response.raise_for_status()
+
+                if self.debug:
+                    print(
+                        f"[DEBUG] Response: {response.text}", file=sys.stderr
+                    )
+
+                gnosis_response = GnosisResponse(**response.json())
+                if gnosis_response.choices and gnosis_response.choices[0].get(
+                    "message", {}
+                ).get("content"):
+                    return str(
+                        gnosis_response.choices[0]["message"]["content"]
+                    )
+
+                return "No response from Deepgram AI"
+            except httpx.HTTPStatusError as e:
+                if self.debug:
+                    print(f"[DEBUG] HTTP Error: {e}", file=sys.stderr)
+                    print(
+                        f"[DEBUG] Response: {e.response.text}", file=sys.stderr
+                    )
+                return (
+                    f"HTTP Error {e.response.status_code}: {e.response.text}"
+                )
+            except Exception as e:
+                error_msg = f"Error calling Deepgram AI: {str(e)}"
+                if self.debug:
+                    import traceback
+
+                    print(f"[DEBUG] {error_msg}", file=sys.stderr)
+                    traceback.print_exc()
+                return error_msg
+
+    async def ask_question(
+        self, question: str, system_prompt: Optional[str] = None
+    ) -> str:
+        """Ask a question to Gnosis with an optional system prompt.
+
+        Args:
+            question: The question to ask.
+            system_prompt: Optional system prompt to set context.
+
+        Returns:
+            The response from Gnosis.
+        """
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": question})
+
+        return await self.call(messages)
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        system_prompt: Optional[str] = None,
+    ) -> str:
+        """Have a conversation with Gnosis.
+
+        Args:
+            messages: List of messages in the conversation.
+            system_prompt: Optional system prompt to prepend.
+
+        Returns:
+            The response from Gnosis.
+        """
+        all_messages = []
+        if system_prompt:
+            all_messages.append({"role": "system", "content": system_prompt})
+        all_messages.extend(messages)
+
+        return await self.call(all_messages)
+
+
+async def main() -> None:
+    """Main function for standalone CLI usage."""
+    import argparse
+
+    # Create parser
+    parser = argparse.ArgumentParser(
+        prog="deepctl_cmd_mcp.gnosis",
+        description="Interact with Deepgram's AI assistant API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Ask a single question
+  python -m deepctl_cmd_mcp.gnosis "What is Deepgram?"
+
+  # Ask with a custom system prompt
+  python -m deepctl_cmd_mcp.gnosis "Explain streaming" \\
+    --system-prompt "You are a technical expert"
+
+  # Interactive chat mode
+  python -m deepctl_cmd_mcp.gnosis --chat
+
+  # JSON output for integration
+  python -m deepctl_cmd_mcp.gnosis "What models are available?" \\
+    --json-output
+
+  # Debug mode to see API calls
+  python -m deepctl_cmd_mcp.gnosis "Test question" --debug
+""",
+    )
+
+    parser.add_argument(
+        "question",
+        nargs="?",
+        help="Question to ask Deepgram AI (omit for interactive chat mode)",
+    )
+    parser.add_argument(
+        "--url",
+        type=str,
+        default="https://gnosis.deepgram.com",
+        help="Base URL for Deepgram AI API",
+    )
+    parser.add_argument(
+        "--api-key",
+        help="Deepgram API key (defaults to DEEPGRAM_API_KEY env var)",
+    )
+    parser.add_argument(
+        "--system-prompt",
+        help="System prompt to set context",
+    )
+    parser.add_argument(
+        "--chat",
+        action="store_true",
+        help="Enable interactive chat mode",
+    )
+    parser.add_argument(
+        "--model",
+        default="deepgram",
+        help="Model to use (default: deepgram)",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.7,
+        help="Temperature for generation (default: 0.7)",
+    )
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        help="Maximum tokens to generate",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug output",
+    )
+    parser.add_argument(
+        "--json-output",
+        action="store_true",
+        help="Output raw JSON response",
+    )
+
+    args = parser.parse_args()
+
+    # Check if we have a question or chat mode
+    if not args.question and not args.chat:
+        parser.print_help()
+        sys.exit(1)
+
+    try:
+        client = GnosisClient(
+            api_key=args.api_key,
+            base_url=args.url,
+            debug=args.debug,
+        )
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        if args.chat:
+            # Interactive chat mode
+            print("Deepgram AI Chat ('exit' to quit, 'clear' to reset)")
+            print("-" * 60)
+
+            history: list[dict[str, str]] = []
+            if args.system_prompt:
+                print(f"System: {args.system_prompt}")
+                print("-" * 60)
+
+            while True:
+                try:
+                    user_input = input("\nYou: ").strip()
+                except (EOFError, KeyboardInterrupt):
+                    print("\nGoodbye!")
+                    break
+
+                if user_input.lower() in ["exit", "quit"]:
+                    print("\nGoodbye!")
+                    break
+                elif user_input.lower() == "clear":
+                    history = []
+                    print("\nChat history cleared.")
+                    continue
+                elif not user_input:
+                    continue
+
+                # Add to history
+                history.append({"role": "user", "content": user_input})
+
+                # Get response
+                response = await client.chat(
+                    history, system_prompt=args.system_prompt
+                )
+
+                # Add response to history
+                history.append({"role": "assistant", "content": response})
+
+                # Display response
+                print(f"\nDeepgram AI: {response}")
+
+        else:
+            # Single question mode
+            if args.json_output:
+                # For JSON output, get the raw response
+                messages = []
+                if args.system_prompt:
+                    messages.append(
+                        {"role": "system", "content": args.system_prompt}
+                    )
+                messages.append({"role": "user", "content": args.question})
+
+                # We need to modify the client to return the full response
+                # For now, just get the text response
+                response = await client.ask_question(
+                    args.question, args.system_prompt
+                )
+                result = {
+                    "question": args.question,
+                    "response": response,
+                    "model": args.model,
+                }
+                print(json.dumps(result, indent=2))
+            else:
+                response = await client.ask_question(
+                    args.question, args.system_prompt
+                )
+                print(response)
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp/models.py

@@ -0,0 +1,24 @@
+"""Models for the MCP command."""
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class TransportType(str, Enum):
+    """Transport types for MCP server."""
+
+    STDIO = "stdio"
+    SSE = "sse"
+    STREAMABLEHTTP = "streamablehttp"
+
+
+class MCPServerResult(BaseModel):
+    """Result of MCP server operation."""
+
+    status: str
+    message: str
+    transport: Optional[TransportType] = None
+    port: Optional[int] = None
+    host: Optional[str] = None

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: deepctl-cmd-mcp
+Version: 0.1.0
+Summary: MCP server command for deepctl to interact with Deepgram's AI assistant service
+Author-email: Deepgram <devrel@deepgram.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: deepctl-core>=0.1.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: rich>=13.9.4
+Requires-Dist: click>=8.1.7
+Requires-Dist: pydantic>=2.10.1
+Requires-Dist: httpx>=0.28.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: pytest-cov>=6.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"
+Requires-Dist: mypy>=1.13.0; extra == "dev"
+Requires-Dist: ruff>=0.8.1; extra == "dev"
+
+# deepctl-cmd-mcp
+
+This package provides two ways to interact with Deepgram's AI assistant:
+
+1. **MCP Server**: Run an MCP server that exposes Deepgram's AI assistant tools
+2. **Python Client**: Standalone Python client for interacting with Deepgram's AI API
+
+## Installation
+
+This package is installed as part of the main deepctl CLI.

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/deepctl_cmd_mcp/__init__.py
+src/deepctl_cmd_mcp/__main__.py
+src/deepctl_cmd_mcp/command.py
+src/deepctl_cmd_mcp/gnosis.py
+src/deepctl_cmd_mcp/models.py
+src/deepctl_cmd_mcp.egg-info/PKG-INFO
+src/deepctl_cmd_mcp.egg-info/SOURCES.txt
+src/deepctl_cmd_mcp.egg-info/dependency_links.txt
+src/deepctl_cmd_mcp.egg-info/entry_points.txt
+src/deepctl_cmd_mcp.egg-info/requires.txt
+src/deepctl_cmd_mcp.egg-info/top_level.txt

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[deepctl.commands]
+mcp = deepctl_cmd_mcp.command:McpCommand

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp.egg-info/requires.txt

@@ -0,0 +1,14 @@
+deepctl-core>=0.1.0
+mcp>=1.0.0
+rich>=13.9.4
+click>=8.1.7
+pydantic>=2.10.1
+httpx>=0.28.1
+
+[dev]
+pytest>=8.3.3
+pytest-asyncio>=0.24.0
+pytest-cov>=6.0.0
+pytest-mock>=3.14.0
+mypy>=1.13.0
+ruff>=0.8.1

deepctl_cmd_mcp-0.1.0/src/deepctl_cmd_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+deepctl_cmd_mcp