eulerian-marketing-platform 0.1.1__tar.gz → 0.2.0__tar.gz

{eulerian_marketing_platform-0.1.1 → eulerian_marketing_platform-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eulerian_marketing_platform
-Version: 0.1.1
+Version: 0.2.0
 Summary: MCP server for Eulerian Marketing Platform - enables AI assistants to interact with Eulerian's marketing analytics and campaign management APIs
 Author-email: Eulerian Technologies <mathieu@eulerian.com>
 License: MIT

{eulerian_marketing_platform-0.1.1 → eulerian_marketing_platform-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "eulerian_marketing_platform"
-version = "0.1.1"
+version = "0.2.0"
 description = "MCP server for Eulerian Marketing Platform - enables AI assistants to interact with Eulerian's marketing analytics and campaign management APIs"
 readme = "README.md"
 authors = [
@@ -26,7 +26,6 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "mcp>=1.2.0",
     "httpx>=0.25.0",
 ]
 requires-python = ">=3.10"
@@ -53,12 +52,5 @@ Issues = "https://github.com/EulerianTechnologies/eulerian-marketing-platform-mc
 Documentation = "https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp#readme"
 Repository = "https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp"
 
-[tool.setuptools]
-package-dir = {"" = "src"}
-
 [tool.setuptools.packages.find]
 where = ["src"]
-namespaces = false
-
-[tool.setuptools.package-data]
-eulerian_marketing_platform = ["py.typed"]

{eulerian_marketing_platform-0.1.1 → eulerian_marketing_platform-0.2.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = eulerian_marketing_platform
-version = 0.1.1
+version = 0.2.0
 
 [options]
 package_dir = 

{eulerian_marketing_platform-0.1.1 → eulerian_marketing_platform-0.2.0}/src/eulerian_marketing_platform/__init__.py

@@ -4,8 +4,12 @@ This package provides a Model Context Protocol (MCP) server that enables
 AI assistants to interact with Eulerian Marketing Platform APIs.
 """
 
-from .server import main
-
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 __author__ = "Eulerian Technologies"
-__all__ = ["main"]
+__all__ = []
+
+# Import main only when explicitly requested
+def get_main():
+    """Lazy import of main function to avoid side effects."""
+    from .server import main
+    return main

eulerian_marketing_platform-0.2.0/src/eulerian_marketing_platform/server.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""Eulerian Marketing Platform MCP Proxy Server.
+
+This server acts as a transparent proxy between local MCP clients (Claude Desktop, etc.)
+and a remote Eulerian Marketing Platform MCP server via HTTP.
+
+It forwards ALL MCP requests directly to the remote server, making all remote tools
+and resources available to the client without any intermediary logic.
+"""
+
+import os
+import sys
+import json
+import logging
+import tempfile
+from datetime import datetime
+import httpx
+
+# Configuration
+EMP_API_ENDPOINT = os.environ.get("EMP_API_ENDPOINT")
+EMP_API_TOKEN = os.environ.get("EMP_API_TOKEN")
+
+# Logging setup - Use cross-platform temp directory
+DEFAULT_LOG_FILE = os.path.join(tempfile.gettempdir(), "eulerian-mcp-proxy.log")
+LOG_FILE = os.environ.get("EMP_LOG_FILE", DEFAULT_LOG_FILE)
+
+# Ensure log directory exists
+log_dir = os.path.dirname(LOG_FILE)
+if log_dir:
+    os.makedirs(log_dir, exist_ok=True)
+
+# Configure logging to file and stderr with UTF-8 encoding for cross-platform compatibility
+file_handler = logging.FileHandler(LOG_FILE, encoding='utf-8')
+file_handler.setLevel(logging.INFO)
+file_handler.setFormatter(logging.Formatter("[%(asctime)s] %(levelname)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S"))
+
+# For stderr, use system encoding with error handling
+stream_handler = logging.StreamHandler(sys.stderr)
+stream_handler.setLevel(logging.INFO)
+stream_handler.setFormatter(logging.Formatter("[%(asctime)s] %(levelname)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S"))
+
+# Configure root logger
+logging.basicConfig(
+    level=logging.INFO,
+    handlers=[file_handler, stream_handler]
+)
+logger = logging.getLogger(__name__)
+
+
+def validate_config() -> None:
+    """Validate that required environment variables are set."""
+    missing_vars = []
+    
+    if not EMP_API_ENDPOINT:
+        missing_vars.append("EMP_API_ENDPOINT")
+    if not EMP_API_TOKEN:
+        missing_vars.append("EMP_API_TOKEN")
+    
+    if missing_vars:
+        logger.error("The following required environment variables are missing:")
+        for var in missing_vars:
+            logger.error(f"  - {var}")
+        logger.error("\nPlease set these environment variables before running the server.")
+        logger.error("Example:")
+        logger.error("  export EMP_API_ENDPOINT=https://your-eulerian-instance.com/api/mcp")
+        logger.error("  export EMP_API_TOKEN=your_authentication_token")
+        sys.exit(1)
+
+
+def forward_request(request_data: dict) -> dict:
+    """Forward a JSON-RPC request to the remote MCP server.
+    
+    Args:
+        request_data: The JSON-RPC request to forward
+        
+    Returns:
+        The JSON-RPC response from the remote server
+    """
+    timeout = float(os.environ.get("EMP_TIMEOUT", "300"))
+    
+    request_id = request_data.get("id")
+    method = request_data.get("method")
+    
+    logger.info(f">>> REQUEST: {method} (id: {request_id})")
+    logger.debug(f"    Full request: {json.dumps(request_data)[:200]}...")
+    
+    try:
+        logger.info(f"Forwarding to {EMP_API_ENDPOINT}")
+        
+        # Use httpx for sync HTTP request
+        with httpx.Client(timeout=timeout) as client:
+            response = client.post(
+                EMP_API_ENDPOINT,
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {EMP_API_TOKEN}"
+                },
+                json=request_data
+            )
+        
+        logger.info(f"<<< RESPONSE: HTTP {response.status_code}")
+        
+        if response.status_code != 200:
+            error_msg = f"HTTP {response.status_code}: {response.reason_phrase}"
+            logger.error(f"    Error: {response.text[:200]}")
+            
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "error": {
+                    "code": -32000,
+                    "message": error_msg
+                }
+            }
+        
+        # Parse response
+        try:
+            response_data = response.json()
+            logger.debug(f"    Response: {json.dumps(response_data)[:200]}...")
+            
+            # Validate JSON-RPC response
+            if "jsonrpc" not in response_data:
+                logger.warning("    WARNING: Missing 'jsonrpc' field")
+            
+            if "result" in response_data:
+                logger.info("    Has 'result' field [OK]")
+            elif "error" in response_data:
+                logger.info(f"    Has 'error' field: {response_data['error']}")
+            
+            return response_data
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"    ERROR: Invalid JSON - {e}")
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "error": {
+                    "code": -32700,
+                    "message": f"Invalid JSON: {str(e)}"
+                }
+            }
+    
+    except httpx.TimeoutException:
+        logger.error("ERROR: Request timeout")
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": -32000,
+                "message": "Request timeout"
+            }
+        }
+    
+    except httpx.RequestError as e:
+        logger.error(f"ERROR: Request failed - {str(e)}")
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": -32000,
+                "message": f"Request failed: {str(e)}"
+            }
+        }
+    
+    except Exception as e:
+        logger.error(f"ERROR: Unexpected error - {str(e)}")
+        import traceback
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": -32000,
+                "message": f"Error: {str(e)}"
+            }
+        }
+
+
+def main() -> None:
+    """Entry point for the MCP proxy server.
+    
+    Runs a transparent stdio proxy that forwards all JSON-RPC requests
+    to the remote Eulerian MCP server.
+    """
+    # Validate configuration
+    validate_config()
+    
+    logger.info("=== EULERIAN MCP PROXY START ===")
+    logger.info(f"Endpoint: {EMP_API_ENDPOINT}")
+    logger.info(f"Token: {EMP_API_TOKEN[:10] if EMP_API_TOKEN else 'None'}...")
+    logger.info(f"Timeout: {float(os.environ.get('EMP_TIMEOUT', '300'))}s")
+    logger.info("Starting stdio proxy - all remote tools will be available")
+    
+    try:
+        # Read from stdin line by line
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            
+            try:
+                # Parse request
+                request_data = json.loads(line)
+                
+                # Forward to remote server
+                response_data = forward_request(request_data)
+                
+                # Send response to stdout
+                response_json = json.dumps(response_data)
+                print(response_json, flush=True)
+                logger.info("    Response forwarded [OK]")
+                
+            except json.JSONDecodeError as e:
+                logger.error(f"ERROR: Invalid JSON in request - {e}")
+                error_response = {
+                    "jsonrpc": "2.0",
+                    "id": None,
+                    "error": {
+                        "code": -32700,
+                        "message": f"Parse error: {str(e)}"
+                    }
+                }
+                print(json.dumps(error_response), flush=True)
+            
+            except Exception as e:
+                logger.error(f"ERROR: Unexpected error processing request - {str(e)}")
+                import traceback
+                logger.error(f"Traceback: {traceback.format_exc()}")
+                error_response = {
+                    "jsonrpc": "2.0",
+                    "id": None,
+                    "error": {
+                        "code": -32000,
+                        "message": f"Error: {str(e)}"
+                    }
+                }
+                print(json.dumps(error_response), flush=True)
+    
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+    except Exception as e:
+        logger.error(f"Server error: {str(e)}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

{eulerian_marketing_platform-0.1.1 → eulerian_marketing_platform-0.2.0}/src/eulerian_marketing_platform.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eulerian-marketing-platform
-Version: 0.1.1
+Version: 0.2.0
 Summary: MCP server for Eulerian Marketing Platform - enables AI assistants to interact with Eulerian's marketing analytics and campaign management APIs
 Author-email: Eulerian Technologies <mathieu@eulerian.com>
 License: MIT

{eulerian_marketing_platform-0.1.1 → eulerian_marketing_platform-0.2.0}/src/eulerian_marketing_platform.egg-info/requires.txt

@@ -1,5 +1,4 @@
 httpx>=0.25.0
-mcp>=1.2.0
 
 [deployment]
 uv>=0.5.0

eulerian_marketing_platform-0.1.1/src/eulerian_marketing_platform/server.py

@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-"""Eulerian Marketing Platform MCP Proxy Server.
-
-This server acts as a proxy/bridge between local MCP clients (Claude Desktop, Gemini CLI, etc.)
-and a remote Eulerian Marketing Platform MCP server via HTTP.
-
-It uses EMP_API_ENDPOINT and EMP_API_TOKEN environment variables to authenticate
-and forward requests to the remote MCP server.
-"""
-
-import os
-import sys
-import json
-import logging
-import tempfile
-from datetime import datetime
-from typing import Any
-from pathlib import Path
-import httpx
-
-from mcp.server.fastmcp import FastMCP
-from mcp.server import Server
-from mcp.server.stdio import stdio_server
-from mcp import types
-
-# Configuration
-EMP_API_ENDPOINT = os.environ.get("EMP_API_ENDPOINT")
-EMP_API_TOKEN = os.environ.get("EMP_API_TOKEN")
-
-# Logging setup - Use cross-platform temp directory
-# Default to system temp directory if EMP_LOG_FILE not set
-DEFAULT_LOG_FILE = os.path.join(tempfile.gettempdir(), "eulerian-mcp-proxy.log")
-LOG_FILE = os.environ.get("EMP_LOG_FILE", DEFAULT_LOG_FILE)
-
-# Ensure log directory exists
-log_dir = os.path.dirname(LOG_FILE)
-if log_dir:  # Only create if there's a directory part
-    os.makedirs(log_dir, exist_ok=True)
-
-# Configure logging to file and stderr
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] %(levelname)s: %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-    handlers=[
-        logging.FileHandler(LOG_FILE),
-        logging.StreamHandler(sys.stderr)
-    ]
-)
-logger = logging.getLogger(__name__)
-
-
-def validate_config() -> None:
-    """Validate that required environment variables are set."""
-    missing_vars = []
-    
-    if not EMP_API_ENDPOINT:
-        missing_vars.append("EMP_API_ENDPOINT")
-    if not EMP_API_TOKEN:
-        missing_vars.append("EMP_API_TOKEN")
-    
-    if missing_vars:
-        logger.error("The following required environment variables are missing:")
-        for var in missing_vars:
-            logger.error(f"  - {var}")
-        logger.error("\nPlease set these environment variables before running the server.")
-        logger.error("Example:")
-        logger.error("  export EMP_API_ENDPOINT=https://your-eulerian-instance.com/api/mcp")
-        logger.error("  export EMP_API_TOKEN=your_authentication_token")
-        sys.exit(1)
-
-
-class EulerianMCPProxy:
-    """Proxy that forwards MCP requests to remote Eulerian server."""
-    
-    def __init__(self):
-        """Initialize the proxy with configuration."""
-        self.endpoint = EMP_API_ENDPOINT
-        self.token = EMP_API_TOKEN
-        self.timeout = float(os.environ.get("EMP_TIMEOUT", "300"))
-        
-        logger.info("=== EULERIAN MCP PROXY START ===")
-        logger.info(f"Endpoint: {self.endpoint}")
-        logger.info(f"Token: {self.token[:10] if self.token else 'None'}...")
-        logger.info(f"Timeout: {self.timeout}s")
-    
-    async def forward_request(self, method: str, params: dict = None) -> dict[str, Any]:
-        """Forward a JSON-RPC request to the remote MCP server.
-        
-        Args:
-            method: The JSON-RPC method name
-            params: The parameters for the method
-            
-        Returns:
-            The response from the remote server
-            
-        Raises:
-            Exception: If the request fails
-        """
-        request_data = {
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": method,
-        }
-        if params:
-            request_data["params"] = params
-        
-        logger.info(f">>> REQUEST: {method}")
-        logger.debug(f"    Full request: {json.dumps(request_data)[:200]}...")
-        
-        try:
-            async with httpx.AsyncClient() as client:
-                logger.info(f"Forwarding to {self.endpoint}")
-                response = await client.post(
-                    self.endpoint,
-                    headers={
-                        "Content-Type": "application/json",
-                        "Authorization": f"Bearer {self.token}"
-                    },
-                    json=request_data,
-                    timeout=self.timeout
-                )
-                
-                logger.info(f"<<< RESPONSE: HTTP {response.status_code}")
-                
-                if response.status_code != 200:
-                    error_msg = f"HTTP {response.status_code}: {response.reason_phrase}"
-                    logger.error(f"    Error: {response.text[:200]}")
-                    raise Exception(error_msg)
-                
-                response_data = response.json()
-                logger.debug(f"    Response: {json.dumps(response_data)[:200]}...")
-                
-                # Validate JSON-RPC response
-                if "jsonrpc" not in response_data:
-                    logger.warning("    WARNING: Missing 'jsonrpc' field")
-                
-                if "result" in response_data:
-                    logger.info("    Has 'result' field [OK]")
-                    return response_data["result"]
-                elif "error" in response_data:
-                    logger.error(f"    Has 'error' field: {response_data['error']}")
-                    raise Exception(f"Remote error: {response_data['error']}")
-                else:
-                    logger.warning("    No 'result' or 'error' field")
-                    return response_data
-                
-        except httpx.TimeoutException:
-            logger.error("ERROR: Request timeout")
-            raise Exception("Request timeout")
-        except httpx.RequestError as e:
-            logger.error(f"ERROR: Request failed - {str(e)}")
-            raise Exception(f"Request failed: {str(e)}")
-        except json.JSONDecodeError as e:
-            logger.error(f"ERROR: Invalid JSON response - {str(e)}")
-            raise Exception(f"Invalid JSON response: {str(e)}")
-
-
-# Create global proxy instance
-proxy = EulerianMCPProxy()
-
-# Create FastMCP server
-mcp = FastMCP("eulerian-marketing-platform")
-
-
-# Dynamically fetch and register tools from remote server
-@mcp.tool()
-async def list_remote_tools() -> dict[str, Any]:
-    """List all available tools from the remote Eulerian MCP server.
-    
-    This tool queries the remote MCP server to discover what tools are available.
-    Use this to see what operations you can perform on the Eulerian platform.
-    
-    Returns:
-        Dictionary containing the list of available tools with their descriptions
-    """
-    try:
-        result = await proxy.forward_request("tools/list")
-        return result
-    except Exception as e:
-        logger.error(f"Failed to list tools: {str(e)}")
-        return {"error": str(e), "tools": []}
-
-
-@mcp.tool()
-async def call_eulerian_tool(tool_name: str, arguments: dict[str, Any] = None) -> dict[str, Any]:
-    """Call a tool on the remote Eulerian MCP server.
-    
-    This is a generic tool that forwards requests to the remote Eulerian platform.
-    First use list_remote_tools() to see what tools are available, then call them
-    using this function.
-    
-    Args:
-        tool_name: The name of the tool to call on the remote server
-        arguments: Dictionary of arguments to pass to the tool (optional)
-        
-    Returns:
-        The result from the remote tool execution
-        
-    Example:
-        To call a tool named "search_goal" with no arguments:
-        >>> call_eulerian_tool("search_goal")
-        
-        To call a tool with arguments:
-            >>> call_eulerian_tool("update_goal", {"action-id": "12345","action-name":"test-mcp"})
-    """
-    if arguments is None:
-        arguments = {}
-    
-    try:
-        params = {
-            "name": tool_name,
-            "arguments": arguments
-        }
-        result = await proxy.forward_request("tools/call", params)
-        return result
-    except Exception as e:
-        logger.error(f"Failed to call tool '{tool_name}': {str(e)}")
-        return {"error": str(e), "tool": tool_name}
-
-
-@mcp.tool()
-async def get_eulerian_resources() -> dict[str, Any]:
-    """List all available resources from the remote Eulerian MCP server.
-    
-    Resources are data sources that can be read from the Eulerian platform,
-    such as configuration files, reports, or reference data.
-    
-    Returns:
-        Dictionary containing the list of available resources
-    """
-    try:
-        result = await proxy.forward_request("resources/list")
-        return result
-    except Exception as e:
-        logger.error(f"Failed to list resources: {str(e)}")
-        return {"error": str(e), "resources": []}
-
-
-@mcp.tool()
-async def read_eulerian_resource(uri: str) -> dict[str, Any]:
-    """Read a specific resource from the remote Eulerian MCP server.
-    
-    Args:
-        uri: The URI of the resource to read (get from get_eulerian_resources())
-        
-    Returns:
-        The content of the requested resource
-        
-    Example:
-        >>> read_eulerian_resource("eulerian://config/settings")
-    """
-    try:
-        params = {"uri": uri}
-        result = await proxy.forward_request("resources/read", params)
-        return result
-    except Exception as e:
-        logger.error(f"Failed to read resource '{uri}': {str(e)}")
-        return {"error": str(e), "uri": uri}
-
-
-@mcp.tool()
-async def get_server_info() -> dict[str, Any]:
-    """Get information about the remote Eulerian MCP server.
-    
-    Returns server capabilities, version, and other metadata.
-    
-    Returns:
-        Dictionary containing server information
-    """
-    try:
-        result = await proxy.forward_request("initialize", {
-            "protocolVersion": "2024-11-05",
-            "capabilities": {},
-            "clientInfo": {
-                "name": "eulerian-mcp-proxy",
-                "version": "0.1.0"
-            }
-        })
-        return result
-    except Exception as e:
-        logger.error(f"Failed to get server info: {str(e)}")
-        return {"error": str(e)}
-
-
-def main() -> None:
-    """Entry point for the MCP proxy server."""
-    # Validate configuration before starting
-    validate_config()
-    
-    logger.info("Starting Eulerian MCP Proxy Server...")
-    logger.info("Available tools:")
-    logger.info("  - list_remote_tools: List all tools from remote server")
-    logger.info("  - call_eulerian_tool: Call any remote tool")
-    logger.info("  - get_eulerian_resources: List available resources")
-    logger.info("  - read_eulerian_resource: Read a specific resource")
-    logger.info("  - get_server_info: Get remote server information")
-    
-    # Run the server in stdio mode (default for MCP)
-    try:
-        mcp.run()
-    except KeyboardInterrupt:
-        logger.info("Server stopped by user")
-    except Exception as e:
-        logger.error(f"Server error: {str(e)}")
-        raise
-
-
-if __name__ == "__main__":
-    main()