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

eulerian_marketing_platform/__init__.py

@@ -4,7 +4,7 @@ This package provides a Model Context Protocol (MCP) server that enables
 AI assistants to interact with Eulerian Marketing Platform APIs.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 __author__ = "Eulerian Technologies"
 __all__ = []
 

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,27 +14,19 @@ 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 with UTF-8 encoding for cross-platform compatibility
@@ -75,176 +67,175 @@ def validate_config() -> None:
         sys.exit(1)
 
 
-class EulerianMCPProxy:
-    """Proxy that forwards MCP requests to remote Eulerian server."""
+def forward_request(request_data: dict) -> dict:
+    """Forward a JSON-RPC request to the remote MCP 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"))
+    Args:
+        request_data: The JSON-RPC request to forward
         
-        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")
+    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")
     
-    async def forward_request(self, method: str, params: dict = None) -> dict[str, Any]:
-        """Forward a JSON-RPC request to the remote MCP server.
+    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}")
         
-        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
+        # 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}")
         
-        logger.info(f">>> REQUEST: {method}")
-        logger.debug(f"    Full request: {json.dumps(request_data)[:200]}...")
+        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:
-            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)}")
+            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 response - {str(e)}")
-            raise Exception(f"Invalid JSON response: {str(e)}")
-
-
-# Dynamically fetch and register tools from remote server
-# (Tools are registered in main() to avoid running on import)
-
-
-def main() -> None:
-    """Entry point for the MCP proxy server."""
-    # Validate configuration before starting
-    validate_config()
-    
-    # Create proxy and server instances (moved here to avoid running on import)
-    global proxy, mcp
-    proxy = EulerianMCPProxy()
-    mcp = FastMCP("eulerian-marketing-platform")
-    
-    # Register tools
-    @mcp.tool()
-    async def list_remote_tools() -> dict[str, Any]:
-        """List all available tools from the remote Eulerian MCP server."""
-        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": []}
+            logger.error(f"    ERROR: Invalid JSON - {e}")
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "error": {
+                    "code": -32700,
+                    "message": f"Invalid JSON: {str(e)}"
+                }
+            }
     
-    @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."""
-        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}
+    except httpx.TimeoutException:
+        logger.error("ERROR: Request timeout")
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": -32000,
+                "message": "Request timeout"
+            }
+        }
     
-    @mcp.tool()
-    async def get_eulerian_resources() -> dict[str, Any]:
-        """List all available resources from the remote Eulerian MCP server."""
-        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": []}
+    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)}"
+            }
+        }
     
-    @mcp.tool()
-    async def read_eulerian_resource(uri: str) -> dict[str, Any]:
-        """Read a specific resource from the remote Eulerian MCP server."""
-        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}
+    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.
     
-    @mcp.tool()
-    async def get_server_info() -> dict[str, Any]:
-        """Get information about the remote Eulerian MCP server."""
-        try:
-            result = await proxy.forward_request("initialize", {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {},
-                "clientInfo": {"name": "eulerian-mcp-proxy", "version": "0.1.1"}
-            })
-            return result
-        except Exception as e:
-            logger.error(f"Failed to get server info: {str(e)}")
-            return {"error": str(e)}
+    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.2.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.2
+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.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-eulerian_marketing_platform/__init__.py,sha256=osuJ8iP6O20ElZXPoZlOQ7sNbZ93kgMz3we8mm_B2-Y,428
-eulerian_marketing_platform/server.py,sha256=bUVn_b05ZritTtNflldCxoFn8YwyrQBqrcbQZ5ceZAg,9810
-eulerian_marketing_platform-0.1.2.dist-info/LICENSE,sha256=eIqBqE_fRsqQJ8F-2v0e-8WzZqdshsCqnzmqLAWrNHU,1078
-eulerian_marketing_platform-0.1.2.dist-info/METADATA,sha256=gfE3v09r1B4dd8Vi_snjgd9JQDWaHplKnZMsp1ML-34,16957
-eulerian_marketing_platform-0.1.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-eulerian_marketing_platform-0.1.2.dist-info/entry_points.txt,sha256=rrPZptATSS9PUtH9gzCYq0WuP6eahkF-DkdUP1FaYfk,88
-eulerian_marketing_platform-0.1.2.dist-info/top_level.txt,sha256=nidh3T6fw-mLjUqZwQ8AiMScS4usuH0WXW4ZgG4HYCo,28
-eulerian_marketing_platform-0.1.2.dist-info/RECORD,,