agenticwerx-mcp-client 1.0.0__py3-none-any.whl

agenticwerx_mcp_client/__init__.py

@@ -0,0 +1,15 @@
+"""
+AgenticWerx MCP Client
+
+A Model Context Protocol (MCP) client for AgenticWerx rule packages.
+Provides universal code analysis across all IDEs and programming languages.
+"""
+
+__version__ = "1.0.0"
+__author__ = "AgenticWerx"
+__email__ = "support@agenticwerx.com"
+
+from .client import AgenticWerxMCPClient
+from .api import AgenticWerxAPI
+
+__all__ = ["AgenticWerxMCPClient", "AgenticWerxAPI"]

agenticwerx_mcp_client/__main__.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+AgenticWerx MCP Client - Entry point for uvx execution
+
+This module serves as the main entry point when the package is executed
+via uvx or python -m agenticwerx_mcp_client.
+"""
+
+import asyncio
+import argparse
+import logging
+import os
+import sys
+from typing import Optional
+
+from .client import AgenticWerxMCPClient
+
+
+def setup_logging(debug: bool = False) -> None:
+    """Configure logging for the application."""
+    level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(sys.stderr)
+        ]
+    )
+
+
+def get_api_key(args_api_key: Optional[str]) -> str:
+    """Get API key from arguments or environment variables."""
+    api_key = args_api_key or os.getenv("AGENTICWERX_API_KEY")
+    
+    if not api_key:
+        print(
+            "Error: API key required via --api-key argument or AGENTICWERX_API_KEY environment variable",
+            file=sys.stderr
+        )
+        print(
+            "Get your API key at: https://agenticwerx.com/dashboard/api-keys",
+            file=sys.stderr
+        )
+        sys.exit(1)
+    
+    return api_key
+
+
+
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    parser = argparse.ArgumentParser(
+        description="AgenticWerx MCP Client - Universal code analysis for all IDEs",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Run with API key from environment
+  export AGENTICWERX_API_KEY=your_key_here
+  agenticwerx-mcp-client
+
+  # Run with API key as argument
+  agenticwerx-mcp-client --api-key your_key_here
+
+
+
+  # Run with debug logging
+  agenticwerx-mcp-client --api-key your_key_here --debug
+
+For more information, visit: https://docs.agenticwerx.com/mcp-client
+        """
+    )
+    
+    parser.add_argument(
+        "--api-key",
+        type=str,
+        help="AgenticWerx API key (can also use AGENTICWERX_API_KEY env var)"
+    )
+    
+
+    
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging"
+    )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"agenticwerx-mcp-client {__import__('agenticwerx_mcp_client').__version__}"
+    )
+    
+    return parser
+
+
+async def async_main() -> None:
+    """Async main function."""
+    parser = create_parser()
+    args = parser.parse_args()
+    
+    # Setup logging
+    setup_logging(args.debug)
+    logger = logging.getLogger(__name__)
+    
+    # Get API key
+    api_key = get_api_key(args.api_key)
+    
+    logger.info("Starting AgenticWerx MCP Client...")
+    logger.debug(f"Debug logging enabled")
+    
+    try:
+        # Create and run the MCP client
+        client = AgenticWerxMCPClient(
+            api_key=api_key,
+            debug=args.debug
+        )
+        
+        await client.run()
+        
+    except KeyboardInterrupt:
+        logger.info("Received interrupt signal, shutting down...")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Fatal error: {e}")
+        if args.debug:
+            logger.exception("Full traceback:")
+        sys.exit(1)
+
+
+def main() -> None:
+    """Main entry point for the application."""
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        sys.exit(0)
+    except Exception as e:
+        print(f"Fatal error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

agenticwerx_mcp_client/api.py

@@ -0,0 +1,239 @@
+"""
+AgenticWerx API client - Lambda MCP communication
+
+This module handles communication with the AgenticWerx Lambda MCP server
+using proper JSON-RPC 2.0 protocol.
+"""
+
+import logging
+import random
+import string
+from typing import Dict, List, Any, Optional
+import httpx
+
+
+logger = logging.getLogger(__name__)
+
+
+class AgenticWerxAPIError(Exception):
+    """Custom exception for API errors."""
+    
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class AgenticWerxAPI:
+    """
+    AgenticWerx Lambda MCP API client.
+    
+    This client connects to the AgenticWerx Lambda MCP server using
+    proper JSON-RPC 2.0 protocol for MCP communication.
+    """
+    
+    def __init__(self, api_key: str):
+        """
+        Initialize the API client.
+        
+        Args:
+            api_key: AgenticWerx API key
+        """
+        self.api_key = api_key
+        self.lambda_url = "https://rph7c2jq5zpisbenj73y2hpjfm0gtwdw.lambda-url.us-west-2.on.aws/"
+        
+        # Create HTTP client with proper headers and timeout
+        self.client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "User-Agent": "AgenticWerx-Lambda-MCP-Client/1.0.0",
+                "Content-Type": "application/json"
+            },
+            timeout=httpx.Timeout(30.0, connect=10.0)
+        )
+        
+        logger.debug(f"Initialized Lambda MCP client for: {self.lambda_url}")
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+    
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self.client.aclose()
+    
+    def _generate_request_id(self) -> str:
+        """Generate a random request ID."""
+        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=7))
+    
+    async def _make_mcp_request(self, method: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """
+        Make an MCP request to the Lambda function.
+        
+        Args:
+            method: MCP method name
+            params: Optional parameters for the method
+            
+        Returns:
+            The result from the MCP server
+        """
+        request_id = self._generate_request_id()
+        
+        mcp_request = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params or {}
+        }
+        
+        logger.debug(f"Making MCP request to Lambda: {method}")
+        logger.debug(f"Request payload: {mcp_request}")
+        
+        try:
+            response = await self.client.post(
+                self.lambda_url,
+                json=mcp_request
+            )
+            
+            logger.debug(f"Response status: {response.status_code}")
+            logger.debug(f"Response headers: {dict(response.headers)}")
+            
+            if response.status_code >= 400:
+                error_text = response.text
+                logger.error(f"Lambda function returned error: {response.status_code} {error_text}")
+                raise AgenticWerxAPIError(
+                    f"Lambda request failed: {response.status_code}",
+                    status_code=response.status_code
+                )
+            
+            try:
+                result = response.json()
+                logger.debug(f"Lambda response received for request {request_id}: {result}")
+            except Exception as json_error:
+                logger.error(f"Failed to parse JSON response: {json_error}")
+                logger.error(f"Raw response: {response.text}")
+                raise AgenticWerxAPIError(f"Invalid JSON response from Lambda: {json_error}")
+            
+            if "error" in result:
+                error_msg = result["error"].get("message", "Unknown MCP error")
+                logger.error(f"MCP error from Lambda: {error_msg}")
+                raise AgenticWerxAPIError(f"MCP Error: {error_msg}")
+            
+            return result.get("result")
+            
+        except httpx.TimeoutException:
+            raise AgenticWerxAPIError("Request timeout")
+        except httpx.ConnectError:
+            raise AgenticWerxAPIError("Connection error")
+        except Exception as e:
+            logger.error(f"Error making MCP request: {e}")
+            raise AgenticWerxAPIError(f"Failed to make MCP request: {str(e)}")
+    
+    async def test_connection(self) -> bool:
+        """
+        Test connection to the Lambda MCP server.
+        
+        Returns:
+            True if connection is successful, False otherwise
+        """
+        try:
+            logger.info("Testing Lambda connection...")
+            result = await self._make_mcp_request("health")
+            logger.info(f"Lambda connection successful: {result}")
+            return True
+        except Exception as e:
+            logger.error(f"Lambda connection test failed: {e}")
+            return False
+    
+    async def list_tools(self) -> List[Dict[str, Any]]:
+        """
+        List available tools from the MCP server.
+        
+        Returns:
+            List of available tools
+        """
+        try:
+            result = await self._make_mcp_request("tools/list")
+            return result.get("tools", [])
+        except Exception as e:
+            logger.error(f"Failed to list tools: {e}")
+            return []
+    
+    async def call_tool(self, name: str, arguments: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Call a tool on the MCP server.
+        
+        Args:
+            name: Tool name
+            arguments: Tool arguments
+            
+        Returns:
+            Tool execution result
+        """
+        try:
+            result = await self._make_mcp_request("tools/call", {
+                "name": name,
+                "arguments": arguments or {}
+            })
+            return result
+        except Exception as e:
+            logger.error(f"Tool call failed for {name}: {e}")
+            raise
+    
+    async def get_rules(self, package_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get rules from the AgenticWerx MCP server.
+        
+        Args:
+            package_id: Optional specific package ID to retrieve
+            
+        Returns:
+            Rules data from the server
+        """
+        logger.debug("Fetching rules via MCP tool call")
+        
+        try:
+            # Use the get_rules tool via MCP
+            arguments = {}
+            if package_id:
+                arguments["packageId"] = package_id
+            
+            result = await self.call_tool("get_rules", arguments)
+            
+            # Extract the actual rules data from the MCP response
+            if "content" in result and result["content"]:
+                # The content should be a list with text content
+                # Look for the JSON content (usually the second item)
+                json_content = None
+                for content_item in result["content"]:
+                    if content_item.get("type") == "text":
+                        text = content_item["text"]
+                        # Try to parse as JSON - if it starts with { or [, it's likely JSON
+                        if text.strip().startswith(("{", "[")):
+                            try:
+                                import json
+                                json_content = json.loads(text)
+                                break
+                            except json.JSONDecodeError:
+                                continue
+                
+                if json_content:
+                    logger.info("Successfully retrieved rules via MCP")
+                    return json_content
+                else:
+                    # If no JSON found, return the raw content
+                    logger.info("No JSON content found, returning raw content")
+                    return {
+                        "content": result["content"],
+                        "message": "Rules retrieved but not in JSON format"
+                    }
+            
+            logger.warning("No rules content found in MCP response")
+            return {"rules": [], "message": "No rules found"}
+            
+        except Exception as e:
+            logger.error(f"Error fetching rules via MCP: {e}")
+            raise AgenticWerxAPIError(f"Failed to fetch rules: {str(e)}")

agenticwerx_mcp_client/client.py

@@ -0,0 +1,221 @@
+"""
+AgenticWerx MCP Client - Simple rule retrieval client
+
+This module implements a simple MCP server that connects to your
+AgenticWerx MCP server to retrieve rules.
+"""
+
+import json
+import logging
+from typing import Any, Dict, List
+
+from mcp.server import Server
+from mcp.types import Resource, Tool, TextContent
+from mcp.server.models import InitializationOptions
+
+from .api import AgenticWerxAPI, AgenticWerxAPIError
+
+
+logger = logging.getLogger(__name__)
+
+
+class AgenticWerxMCPClient:
+    """
+    Simple AgenticWerx MCP Client for rule retrieval.
+    
+    This client connects to your AgenticWerx MCP server and provides
+    a simple interface to get rules through the MCP protocol.
+    """
+    
+    def __init__(self, api_key: str, debug: bool = False):
+        """
+        Initialize the MCP client.
+        
+        Args:
+            api_key: AgenticWerx API key
+            debug: Enable debug logging
+        """
+        self.api_key = api_key
+        self.debug = debug
+        
+        # Initialize the API client
+        self.api = AgenticWerxAPI(api_key)
+        
+        # Initialize the MCP server
+        self.server = Server("agenticwerx")
+        
+        # Configure logging
+        if debug:
+            logging.getLogger().setLevel(logging.DEBUG)
+        
+        logger.info("Initializing AgenticWerx MCP Client")
+        
+        # Set up MCP handlers
+        self._setup_handlers()
+    
+    def _setup_handlers(self) -> None:
+        """Set up MCP server handlers."""
+        
+        @self.server.list_resources()
+        async def list_resources() -> List[Resource]:
+            """List available rule resources."""
+            logger.debug("Listing available rule resources")
+            
+            try:
+                # Test if we can get rules from the Lambda MCP server
+                rules_data = await self.api.get_rules()
+                
+                # Create a single resource for all rules
+                resource = Resource(
+                    uri="agenticwerx://rules",
+                    name="AgenticWerx Rules",
+                    description="All available AgenticWerx rules from Lambda MCP server",
+                    mimeType="application/json"
+                )
+                
+                logger.info("Listed rule resources from Lambda MCP server")
+                return [resource]
+                
+            except AgenticWerxAPIError as e:
+                logger.error(f"API error listing resources: {e}")
+                return []
+            except Exception as e:
+                logger.error(f"Unexpected error listing resources: {e}")
+                return []
+        
+        @self.server.read_resource()
+        async def read_resource(uri: str) -> str:
+            """Read rule resource."""
+            logger.debug(f"Reading resource: {uri}")
+            
+            if uri != "agenticwerx://rules":
+                raise ValueError(f"Unknown resource URI: {uri}")
+            
+            try:
+                rules_data = await self.api.get_rules()
+                logger.debug("Successfully read rules resource from Lambda MCP server")
+                return json.dumps(rules_data, indent=2)
+                
+            except AgenticWerxAPIError as e:
+                logger.error(f"API error reading resource: {e}")
+                raise
+            except Exception as e:
+                logger.error(f"Unexpected error reading resource: {e}")
+                raise ValueError(f"Failed to read resource: {str(e)}")
+        
+        @self.server.list_tools()
+        async def list_tools() -> List[Tool]:
+            """List available tools."""
+            logger.debug("Listing available tools")
+            
+            # Only provide the analyze tool (which calls get_rules internally)
+            tools = [
+                Tool(
+                    name="analyze",
+                    description="Analyze code using AgenticWerx rules. Optionally specify a packageId to use rules from a specific package.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "packageId": {
+                                "type": "string",
+                                "description": "Optional package ID to use rules from a specific package"
+                            }
+                        },
+                        "additionalProperties": False
+                    }
+                )
+            ]
+            
+            logger.info(f"Listed {len(tools)} available tools (analyze only)")
+            return tools
+        
+        @self.server.call_tool()
+        async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+            """Execute a tool."""
+            logger.debug(f"Executing tool: {name}")
+            
+            try:
+                if name == "analyze":
+                    # Handle analyze tool - internally calls get_rules
+                    package_id = arguments.get("packageId") or arguments.get("package_id")
+                    result = await self.api.get_rules(package_id)
+                    
+                    response = {
+                        "tool": "analyze",
+                        "packageId": package_id,
+                        "rules": result
+                    }
+                    
+                    logger.debug("Successfully retrieved rules for analysis")
+                    return [TextContent(type="text", text=json.dumps(response, indent=2))]
+                
+                else:
+                    # Only analyze tool is supported
+                    error_msg = f"Tool '{name}' is not supported. Only 'analyze' tool is available."
+                    logger.warning(f"Unsupported tool requested: {name}")
+                    return [TextContent(type="text", text=json.dumps({"error": error_msg}, indent=2))]
+                
+            except AgenticWerxAPIError as e:
+                error_msg = f"AgenticWerx API Error: {str(e)}"
+                logger.error(f"API error in tool {name}: {e}")
+                return [TextContent(type="text", text=json.dumps({"error": error_msg}, indent=2))]
+            
+            except Exception as e:
+                error_msg = f"Tool execution error: {str(e)}"
+                logger.error(f"Unexpected error in tool {name}: {e}")
+                return [TextContent(type="text", text=json.dumps({"error": error_msg}, indent=2))]
+    
+    async def test_connection(self) -> bool:
+        """Test connection to the Lambda MCP server."""
+        return await self.api.test_connection()
+    
+    async def run(self) -> None:
+        """Run the MCP server."""
+        logger.info("Starting AgenticWerx MCP Client")
+        
+        # Test connection to Lambda MCP server on startup
+        logger.info("Testing connection to Lambda MCP server...")
+        connection_ok = await self.test_connection()
+        if not connection_ok:
+            logger.error("Failed to connect to Lambda MCP server")
+            # Continue anyway - the client might still work for some operations
+        else:
+            logger.info("Successfully connected to Lambda MCP server")
+        
+        try:
+            from mcp.server.stdio import stdio_server
+            
+            async with stdio_server() as (read_stream, write_stream):
+                logger.info("MCP Client started, waiting for connections...")
+                
+                from mcp.types import ServerCapabilities, ResourcesCapability, ToolsCapability
+                
+                init_options = InitializationOptions(
+                    server_name="agenticwerx",
+                    server_version="1.0.0",
+                    capabilities=ServerCapabilities(
+                        resources=ResourcesCapability(subscribe=False, listChanged=False),
+                        tools=ToolsCapability(listChanged=False)
+                    )
+                )
+                
+                await self.server.run(
+                    read_stream,
+                    write_stream,
+                    init_options
+                )
+                
+        except Exception as e:
+            logger.error(f"Error running MCP server: {e}")
+            raise
+        finally:
+            await self.api.close()
+            logger.info("AgenticWerx MCP Client stopped")
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.api.close()

agenticwerx_mcp_client-1.0.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: agenticwerx-mcp-client
+Version: 1.0.0
+Summary: Simple MCP client that connects to your AgenticWerx MCP server to retrieve rules
+Project-URL: Homepage, https://agenticwerx.com
+Project-URL: Documentation, https://docs.agenticwerx.com/mcp-client
+Project-URL: Bug Reports, https://github.com/agenticwerx/mcp-client/issues
+Project-URL: Source Code, https://github.com/agenticwerx/mcp-client
+Author-email: AgenticWerx <support@agenticwerx.com>
+License: MIT
+License-File: LICENSE
+Keywords: agenticwerx,client,mcp,rules
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0; python_version < '3.10'
+Provides-Extra: dev
+Requires-Dist: bandit>=1.7.0; extra == 'dev'
+Requires-Dist: build>=0.10.0; extra == 'dev'
+Requires-Dist: mypy>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: safety>=2.3.0; extra == 'dev'
+Requires-Dist: twine>=4.0.0; extra == 'dev'
+Requires-Dist: types-requests>=2.31.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# AgenticWerx MCP Client
+
+[![PyPI version](https://badge.fury.io/py/agenticwerx-mcp-client.svg)](https://badge.fury.io/py/agenticwerx-mcp-client)
+[![Python Support](https://img.shields.io/pypi/pyversions/agenticwerx-mcp-client.svg)](https://pypi.org/project/agenticwerx-mcp-client/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A Model Context Protocol (MCP) client that connects to the AgenticWerx Lambda MCP server using JSON-RPC 2.0 protocol to provide code analysis and rule management capabilities.
+
+## 🚀 Quick Start
+
+### For IDE Users
+
+Add this configuration to your MCP-compatible IDE (Kiro, Amazon Q Developer, etc.):
+
+```json
+{
+  "mcpServers": {
+    "agenticwerx": {
+      "command": "uvx",
+      "args": ["agenticwerx-mcp-client@latest", "--api-key", "${AGENTICWERX_API_KEY}"],
+      "env": {
+        "AGENTICWERX_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### Get Your API Key
+
+1. Visit [AgenticWerx Dashboard](https://agenticwerx.com/dashboard)
+2. Navigate to API Keys section
+3. Create a new API key
+4. Copy the key to your MCP configuration
+
+## 🛠️ Available Tools
+
+The AgenticWerx MCP client provides a simple tool for code analysis:
+
+### **analyze**
+Analyze code using AgenticWerx rules from the server.
+
+**Parameters:**
+- `packageId` (optional): Specific package ID to use rules from a specific package
+
+**Example:**
+```json
+{
+  "tool": "analyze",
+  "packageId": "stripe-integration-excellence-pack"
+}
+```
+
+The tool connects to AgenticWerx services and retrieves the rules, which are then processed and returned to your IDE.
+
+## 🔗 Simple Connection
+
+This client acts as a simple bridge between your IDE and AgenticWerx services. It retrieves rules and passes them back to your IDE for code analysis.
+
+## 🔧 Installation Methods
+
+### Method 1: UVX (Recommended)
+No installation needed! Your IDE will automatically download and run the client:
+
+```bash
+uvx agenticwerx-mcp-client@latest --api-key your_key_here
+```
+
+### Method 2: pip install
+```bash
+pip install agenticwerx-mcp-client
+agenticwerx-mcp-client --api-key your_key_here
+```
+
+### Method 3: From Source
+```bash
+git clone https://github.com/agenticwerx/mcp-client.git
+cd mcp-client
+pip install -e .
+agenticwerx-mcp-client --api-key your_key_here
+```
+
+## 📋 IDE Configuration Examples
+
+### Kiro IDE
+```json
+{
+  "mcpServers": {
+    "agenticwerx": {
+      "command": "uvx",
+      "args": ["agenticwerx-mcp-client@latest", "--api-key", "${AGENTICWERX_API_KEY}"],
+      "env": {
+        "AGENTICWERX_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### Amazon Q Developer
+```json
+{
+  "mcpServers": {
+    "agenticwerx": {
+      "command": "uvx",
+      "args": ["agenticwerx-mcp-client@latest", "--api-key", "${AGENTICWERX_API_KEY}"],
+      "env": {
+        "AGENTICWERX_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### VS Code (with MCP extension)
+```json
+{
+  "mcp.servers": {
+    "agenticwerx": {
+      "command": "uvx",
+      "args": ["agenticwerx-mcp-client@latest", "--api-key", "${AGENTICWERX_API_KEY}"],
+      "env": {
+        "AGENTICWERX_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+## 🔒 Security & Privacy
+
+- **API Key Security:** Your API key is only used to authenticate with AgenticWerx services
+- **Code Privacy:** Code analysis happens securely through encrypted connections
+- **No Data Storage:** Your code is analyzed in real-time and not stored on our servers
+- **Local Processing:** The MCP client runs locally on your machine
+
+## 🚀 Features
+
+- ✅ **Simple Connection:** Connects your IDE to AgenticWerx services
+- ✅ **Rule Retrieval:** Fetches rules from the server
+- ✅ **MCP Compatible:** Works with any MCP-compatible IDE
+- ✅ **Zero Configuration:** Just add your API key
+- ✅ **Lightweight:** Minimal overhead, just passes data through
+
+## 📊 Example Output
+
+```json
+{
+  "tool": "analyze",
+  "packageId": "stripe-integration-excellence-pack",
+  "rules": {
+    "rules": [
+      {
+        "id": "rule-1",
+        "name": "Security Rule",
+        "description": "Prevents security vulnerabilities",
+        "pattern": "eval\\(",
+        "message": "Avoid using eval() as it can lead to code injection"
+      }
+    ],
+    "metadata": {
+      "package_name": "Security Rules",
+      "version": "1.0.0",
+      "total_rules": 1
+    }
+  }
+}
+```
+
+## 🛠️ Technical Requirements
+
+### Runtime Requirements
+- Python 3.8+
+- httpx >= 0.25.0
+- mcp >= 1.0.0
+- pydantic >= 2.0.0
+
+### Installation
+```bash
+# Via uvx (recommended)
+uvx agenticwerx-mcp-client@latest --api-key your_key_here
+
+# Via pip
+pip install agenticwerx-mcp-client
+```
+
+## 📚 Documentation
+
+- [Full Documentation](https://docs.agenticwerx.com/mcp-client)
+- [API Reference](https://docs.agenticwerx.com/api)
+- [Rule Package Catalog](https://agenticwerx.com/packages)
+- [IDE Integration Guides](https://docs.agenticwerx.com/integrations)
+
+## 🆘 Support
+
+- **Documentation:** [docs.agenticwerx.com](https://docs.agenticwerx.com)
+- **Email Support:** [support@agenticwerx.com](mailto:support@agenticwerx.com)
+- **Community:** [Discord Server](https://discord.gg/agenticwerx)
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+**Note:** This is a proprietary package developed and maintained exclusively by AgenticWerx. We do not accept external contributions at this time.
+
+## 🔄 Changelog
+
+### v1.0.0 (2025-01-XX)
+- Initial release
+- Full MCP protocol support
+- Rule retrieval tools
+- Multi-language support
+- Real-time code feedback
+
+---
+
+**Built with ❤️ by the AgenticWerx Team**
+
+*Making code quality accessible to every developer, in every IDE, for every language.*

agenticwerx_mcp_client-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+agenticwerx_mcp_client/__init__.py,sha256=gNU_Q5Vxp_VnsKaq7YuHI4hYQ2k-o-3O2aZV6tQqNVU,392
+agenticwerx_mcp_client/__main__.py,sha256=zo38csH7kS-iEP1v3DrOIoY2y_h9-3RHG_g-JqQNcTc,3564
+agenticwerx_mcp_client/api.py,sha256=y14uWFFzu_YxPAu7UcuqQKCnNdzRJR5nN8KHmUKykTc,8547
+agenticwerx_mcp_client/client.py,sha256=k8_1pblBqHi9B83A3xF7okfxnX0DTPy8WIpXlCkeQHs,8572
+agenticwerx_mcp_client-1.0.0.dist-info/METADATA,sha256=iVy-vf-EkDY7wgmAk19lOB4fWf5A02LORyEr0Bpy0BI,7819
+agenticwerx_mcp_client-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+agenticwerx_mcp_client-1.0.0.dist-info/entry_points.txt,sha256=JZ_xQZG_DpeObI-W0Kkl_xJyuuWyDvp4nvvNEoTBnSo,80
+agenticwerx_mcp_client-1.0.0.dist-info/licenses/LICENSE,sha256=q2BReOYGJ-oS4jzVbLIsPVDk1Gxw89w3EvFxTKEBfNk,1067
+agenticwerx_mcp_client-1.0.0.dist-info/RECORD,,

agenticwerx_mcp_client-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agenticwerx_mcp_client-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agenticwerx-mcp-client = agenticwerx_mcp_client.__main__:main

agenticwerx_mcp_client-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AgenticWerx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.