eulerian-marketing-platform 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

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/server.py

@@ -1,11 +1,11 @@
 #!/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.)
+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 uses EMP_API_ENDPOINT and EMP_API_TOKEN environment variables to authenticate
-and forward requests to the remote MCP server.
+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
@@ -14,38 +14,35 @@ 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
+if log_dir:
     os.makedirs(log_dir, exist_ok=True)
 
-# Configure logging to file and stderr
+# 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,
-    format="[%(asctime)s] %(levelname)s: %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-    handlers=[
-        logging.FileHandler(LOG_FILE),
-        logging.StreamHandler(sys.stderr)
-    ]
+    handlers=[file_handler, stream_handler]
 )
 logger = logging.getLogger(__name__)
 
@@ -70,235 +67,175 @@ def validate_config() -> None:
         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.
+def forward_request(request_data: dict) -> dict:
+    """Forward a JSON-RPC request to the remote MCP server.
     
     Args:
-        tool_name: The name of the tool to call on the remote server
-        arguments: Dictionary of arguments to pass to the tool (optional)
+        request_data: The JSON-RPC request to forward
         
     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"})
+        The JSON-RPC response from the remote server
     """
-    if arguments is None:
-        arguments = {}
+    timeout = float(os.environ.get("EMP_TIMEOUT", "300"))
     
-    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.
+    request_id = request_data.get("id")
+    method = request_data.get("method")
     
-    Resources are data sources that can be read from the Eulerian platform,
-    such as configuration files, reports, or reference data.
+    logger.info(f">>> REQUEST: {method} (id: {request_id})")
+    logger.debug(f"    Full request: {json.dumps(request_data)[:200]}...")
     
-    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())
+        logger.info(f"Forwarding to {EMP_API_ENDPOINT}")
         
-    Returns:
-        The content of the requested resource
+        # 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
+            )
         
-    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.
+        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)}"
+                }
+            }
     
-    Returns server capabilities, version, and other metadata.
+    except httpx.TimeoutException:
+        logger.error("ERROR: Request timeout")
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": -32000,
+                "message": "Request timeout"
+            }
+        }
     
-    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"
+    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)}"
             }
-        })
-        return result
+        }
+    
     except Exception as e:
-        logger.error(f"Failed to get server info: {str(e)}")
-        return {"error": str(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."""
-    # Validate configuration before starting
+    """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("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")
+    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")
     
-    # Run the server in stdio mode (default for MCP)
     try:
-        mcp.run()
+        # 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:

{eulerian_marketing_platform-0.1.1.dist-info → eulerian_marketing_platform-0.2.0.dist-info}/METADATA

@@ -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
@@ -24,7 +24,6 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx (>=0.25.0)
-Requires-Dist: mcp (>=1.2.0)
 Provides-Extra: deployment
 Requires-Dist: uv (>=0.5.0) ; extra == 'deployment'
 Provides-Extra: dev

eulerian_marketing_platform-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+eulerian_marketing_platform/__init__.py,sha256=8Od_2veelx75AfbIEFrCS1UF6AOsKaX6CF4zR_z8yYU,428
+eulerian_marketing_platform/server.py,sha256=y1vy-LvSjG18dvDv65hO875s_7vogbb5bdNwTetKKcU,8335
+eulerian_marketing_platform-0.2.0.dist-info/LICENSE,sha256=eIqBqE_fRsqQJ8F-2v0e-8WzZqdshsCqnzmqLAWrNHU,1078
+eulerian_marketing_platform-0.2.0.dist-info/METADATA,sha256=B0l6BxIaS-m55cFeicvSsHEhwVKZAmwy2OaFM9eWYpY,16928
+eulerian_marketing_platform-0.2.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+eulerian_marketing_platform-0.2.0.dist-info/entry_points.txt,sha256=rrPZptATSS9PUtH9gzCYq0WuP6eahkF-DkdUP1FaYfk,88
+eulerian_marketing_platform-0.2.0.dist-info/top_level.txt,sha256=nidh3T6fw-mLjUqZwQ8AiMScS4usuH0WXW4ZgG4HYCo,28
+eulerian_marketing_platform-0.2.0.dist-info/RECORD,,

eulerian_marketing_platform-0.1.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-eulerian_marketing_platform/__init__.py,sha256=Rn4OZQAUsvh-s5Sq2un79qnJ50dnFvAFr0jMHXMVgWQ,291
-eulerian_marketing_platform/server.py,sha256=R7qW5Fclv1sbcFEN5L4Upe6c-BwXsod6Q16Tuyxgc9c,10712
-eulerian_marketing_platform-0.1.1.dist-info/LICENSE,sha256=eIqBqE_fRsqQJ8F-2v0e-8WzZqdshsCqnzmqLAWrNHU,1078
-eulerian_marketing_platform-0.1.1.dist-info/METADATA,sha256=2U6mXMEf2-RecN3bIB_zspSZCgCcoiIJg67zTCa_pZ4,16957
-eulerian_marketing_platform-0.1.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-eulerian_marketing_platform-0.1.1.dist-info/entry_points.txt,sha256=rrPZptATSS9PUtH9gzCYq0WuP6eahkF-DkdUP1FaYfk,88
-eulerian_marketing_platform-0.1.1.dist-info/top_level.txt,sha256=nidh3T6fw-mLjUqZwQ8AiMScS4usuH0WXW4ZgG4HYCo,28
-eulerian_marketing_platform-0.1.1.dist-info/RECORD,,