eulerian-marketing-platform 0.1.0__py3-none-any.whl

eulerian_marketing_platform/__init__.py

@@ -0,0 +1,11 @@
+"""Eulerian Marketing Platform MCP Server.
+
+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.0"
+__author__ = "Eulerian Technologies"
+__all__ = ["main"]

eulerian_marketing_platform/server.py

@@ -0,0 +1,310 @@
+#!/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()

eulerian_marketing_platform-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eulerian Technologies
+
+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.

eulerian_marketing_platform-0.1.0.dist-info/METADATA

@@ -0,0 +1,567 @@
+Metadata-Version: 2.1
+Name: eulerian-marketing-platform
+Version: 0.1.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
+Project-URL: Homepage, https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp
+Project-URL: Issues, https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp/issues
+Project-URL: Documentation, https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp#readme
+Project-URL: Repository, https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+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
+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
+Requires-Dist: black (>=23.0.0) ; extra == 'dev'
+Requires-Dist: mypy (>=1.0.0) ; extra == 'dev'
+Requires-Dist: pytest-asyncio (>=0.21.0) ; extra == 'dev'
+Requires-Dist: pytest-cov (>=4.0.0) ; extra == 'dev'
+Requires-Dist: pytest (>=7.0.0) ; extra == 'dev'
+Requires-Dist: ruff (>=0.1.0) ; extra == 'dev'
+
+# Eulerian Marketing Platform MCP Server
+
+A Model Context Protocol (MCP) **proxy server** that bridges AI assistants (Claude Desktop, Gemini CLI, Mistral AI) to a remote Eulerian Marketing Platform MCP server. This proxy handles authentication, request forwarding, and provides a local MCP interface to your remote Eulerian instance.
+
+## How It Works
+
+This server acts as a **transparent proxy** between local MCP clients and your remote Eulerian Marketing Platform server:
+
+```
+┌─────────────┐        ┌──────────────────┐        ┌────────────────┐
+│   Claude    │ ◄─────►│  This MCP Proxy  │◄─────► │ Remote Eulerian│
+│   Desktop   │  stdio │  (Local)         │  HTTP  │  MCP Server    │
+└─────────────┘        └──────────────────┘        └────────────────┘
+```
+
+The proxy:
+- 🔐 Handles authentication with your remote Eulerian server
+- 📡 Forwards MCP requests via HTTP with Bearer token
+- 🛠️ Exposes remote tools and resources to AI assistants
+- 📝 Provides comprehensive logging for debugging
+- ⚡ Uses async HTTP for better performance
+
+## Features
+
+- **🔌 Proxy Architecture**: Bridges local MCP clients to remote Eulerian MCP server via HTTP
+- **🔐 Secure Authentication**: Uses Bearer token authentication for remote server access
+- **🌐 Cross-platform support**: Works on Windows, Linux, and macOS
+- **🤖 Multiple AI clients**: Compatible with Claude Desktop, Gemini CLI, and Mistral AI
+- **📝 Comprehensive Logging**: Logs all requests/responses for debugging
+- **⚡ Async HTTP**: Non-blocking requests using httpx for better performance
+- **🛠️ Tool Discovery**: Automatically discovers and exposes remote tools
+- **⏱️ Configurable Timeouts**: Adjustable request timeouts
+- **🔍 Easy Installation**: Deploy with a single command using `uvx`
+
+## Prerequisites
+
+- Python 3.10 or higher
+- Access to a remote Eulerian Marketing Platform MCP server (HTTP endpoint)
+- Valid authentication token for the remote server
+- One of the following AI clients:
+  - Claude Desktop (Windows, macOS, Linux)
+  - Gemini CLI
+  - Mistral AI Le Chat (requires remote deployment)
+
+## Available Tools
+
+The proxy exposes the following tools to AI assistants:
+
+1. **`list_remote_tools()`** - Discover all tools available on the remote Eulerian server
+2. **`call_eulerian_tool(tool_name, arguments)`** - Call any remote tool with arguments
+3. **`get_eulerian_resources()`** - List available resources (data sources)
+4. **`read_eulerian_resource(uri)`** - Read a specific resource by URI
+5. **`get_server_info()`** - Get remote server version and capabilities
+
+For detailed information on how these tools work, see [FASTMCP_PROXY_GUIDE.md](FASTMCP_PROXY_GUIDE.md).
+
+## Installation
+
+### Prerequisites Check
+
+Before installing, verify you have `uvx` installed. This is the recommended way to run the MCP server.
+
+**Check if uvx is installed:**
+```bash
+uvx --version
+```
+
+**If not installed, see [UVX_DEPLOYMENT_GUIDE.md](UVX_DEPLOYMENT_GUIDE.md) for detailed installation instructions.**
+
+**Quick install (Linux/macOS):**
+```bash
+# Run the included script
+chmod +x install-uvx.sh
+./install-uvx.sh
+
+# Or install manually
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+**Quick install (Windows PowerShell - Run as Administrator):**
+```powershell
+# Run the included script
+.\install-uvx.ps1
+
+# Or install manually
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+---
+
+### Quick Start (Recommended)
+
+The easiest way to use this MCP server is with `uvx`, which automatically handles dependencies without requiring a separate installation:
+
+```bash
+# No installation needed! Just configure your AI client (see below)
+```
+
+### Alternative: Install via pip
+
+If you prefer to install the package globally:
+
+```bash
+pip install eulerian-marketing-platform
+```
+
+### Alternative: Install from source
+
+```bash
+git clone https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp.git
+cd eulerian-marketing-platform-mcp
+pip install -e .
+```
+
+## Configuration
+
+### Required Environment Variables
+
+- `EMP_API_ENDPOINT`: Your remote Eulerian Marketing Platform MCP server URL (HTTP endpoint)
+  - Example: `https://your-eulerian-instance.com/api/mcp`
+- `EMP_API_TOKEN`: Your authentication token for the remote server
+
+### Optional Environment Variables
+
+- `EMP_LOG_FILE`: Log file location (default: `/tmp/eulerian-mcp-proxy.log`)
+- `EMP_TIMEOUT`: Request timeout in seconds (default: `300`)
+
+### Example `.env` file
+
+Create a `.env.example` file in your project:
+
+```bash
+# Required
+EMP_API_ENDPOINT=https://your-eulerian-instance.com/mcp
+EMP_API_TOKEN=your_authentication_token_here
+
+# Optional
+EMP_LOG_FILE=/var/log/eulerian-mcp-proxy.log
+EMP_TIMEOUT=600
+```
+
+## Setup Instructions by Client
+
+### 1. Claude Desktop
+
+Claude Desktop supports local MCP servers via stdio transport.
+
+#### Configuration File Locations
+
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+#### Setup Steps
+
+1. **Open Claude Desktop**
+2. **Access configuration**:
+   - Click `Claude` menu → `Settings` → `Developer` → `Edit Config`
+   - Or manually edit the JSON file at the location above
+
+3. **Add the server configuration**:
+
+```json
+{
+  "mcpServers": {
+    "eulerian-marketing-platform": {
+      "command": "uvx",
+      "args": ["eulerian-marketing-platform"],
+      "env": {
+        "EMP_API_ENDPOINT": "https://your-eulerian-instance.com/mcp",
+        "EMP_API_TOKEN": "your_authentication_token_here"
+      }
+    }
+  }
+}
+```
+
+**Alternative: If using pip installation**:
+
+```json
+{
+  "mcpServers": {
+    "eulerian-marketing-platform": {
+      "command": "python",
+      "args": ["-m", "eulerian_marketing_platform.server"],
+      "env": {
+        "EMP_API_ENDPOINT": "https://your-eulerian-instance.com/mcp",
+        "EMP_API_TOKEN": "your_authentication_token_here"
+      }
+    }
+  }
+}
+```
+
+4. **Restart Claude Desktop**
+
+5. **Verify the connection**:
+   - Look for a hammer/tools icon (🔨) in the bottom-right corner
+   - Click it to see available Eulerian tools
+   - Ask Claude: "What Eulerian Marketing Platform tools do you have access to?"
+
+#### Platform-Specific Notes
+
+**Windows**:
+- Use the Run dialog (`Win + R`) and enter `%APPDATA%\Claude` to quickly navigate to the config directory
+- If using a local installation, ensure Python is in your PATH
+
+**Linux**:
+- The config directory may not exist initially - create it with: `mkdir -p ~/.config/Claude`
+- Ensure `uvx` is installed: `pip install uv`
+
+**macOS**:
+- Access the config via Finder: `Cmd + Shift + G` → `~/Library/Application Support/Claude/`
+
+---
+
+### 2. Gemini CLI
+
+Gemini CLI supports MCP servers through its configuration file.
+
+#### Prerequisites
+
+Install Gemini CLI if you haven't already:
+
+```bash
+npm install -g @google/gemini-cli
+```
+
+#### Configuration File Location
+
+`~/.gemini/settings.json`
+
+#### Setup Steps
+
+1. **Create or edit the settings file**:
+
+```bash
+# Create the directory if it doesn't exist
+mkdir -p ~/.gemini
+
+# Edit the settings file
+nano ~/.gemini/settings.json
+```
+
+2. **Add the MCP server configuration**:
+
+```json
+{
+  "mcpServers": {
+    "eulerian-marketing-platform": {
+      "command": "uvx",
+      "args": ["eulerian-marketing-platform"],
+      "env": {
+        "EMP_API_ENDPOINT": "https://your-eulerian-instance.com/mcp",
+        "EMP_API_TOKEN": "your_authentication_token_here"
+      }
+    }
+  }
+}
+```
+
+3. **Start Gemini CLI**:
+
+```bash
+gemini
+```
+
+4. **Verify the connection**:
+   - Use the `/mcp` command to see connected servers
+   - Ask Gemini: "What tools are available from the Eulerian Marketing Platform?"
+
+#### Platform-Specific Notes
+
+**Windows**:
+- Settings file location: `%USERPROFILE%\.gemini\settings.json`
+- Create directory: `mkdir %USERPROFILE%\.gemini`
+
+**Linux/macOS**:
+- Standard location: `~/.gemini/settings.json`
+
+---
+
+### 3. Mistral AI (Le Chat)
+
+Mistral's Le Chat web interface supports MCP servers through **Custom Connectors**, but they must be deployed as **remote servers** with HTTP/SSE transport.
+
+#### Important Limitations
+
+- ❌ **Local stdio servers are NOT supported** by Mistral Le Chat
+- ✅ **Only remote HTTP/SSE servers** are supported
+- 📡 Your server must be publicly accessible via HTTPS
+
+#### Deployment Options
+
+You'll need to deploy your MCP server to a cloud platform. Popular options include:
+
+- **Render** (https://render.com)
+- **Railway** (https://railway.app)
+- **Fly.io** (https://fly.io)
+- **AWS Lambda** (with API Gateway)
+- **Google Cloud Run**
+- **Azure Container Instances**
+
+#### Server Modification for Remote Deployment
+
+Modify the `server.py` to support HTTP/SSE transport:
+
+```python
+# In your server.py main() function
+def main() -> None:
+    """Entry point for the MCP server."""
+    validate_config()
+    
+    # For remote deployment (Mistral AI)
+    import sys
+    if "--remote" in sys.argv:
+        mcp.run(transport="sse", port=8000)
+    else:
+        # Default stdio for local clients
+        mcp.run()
+```
+
+#### Example: Deploy to Render
+
+1. **Create a `render.yaml` file**:
+
+```yaml
+services:
+  - type: web
+    name: eulerian-mcp-server
+    env: python
+    buildCommand: pip install -e .
+    startCommand: python -m eulerian_marketing_platform.server --remote
+    envVars:
+      - key: EMP_API_ENDPOINT
+        sync: false
+      - key: EMP_API_TOKEN
+        sync: false
+```
+
+2. **Push to GitHub and connect to Render**
+
+3. **Set environment variables in Render dashboard**
+
+#### Setup in Mistral Le Chat
+
+1. **Open Le Chat** (https://chat.mistral.ai)
+
+2. **Navigate to Connectors**:
+   - Click the sidebar toggle
+   - Go to `Intelligence` → `Connectors`
+   - Click `+ Add Connector`
+   - Select `Add custom connector`
+
+3. **Configure the connector**:
+   - **Name**: Eulerian Marketing Platform
+   - **URL**: `https://your-deployed-server.render.com/mcp`
+   - **Description**: Access to Eulerian Marketing Platform analytics and campaigns
+   - **Authentication**: 
+     - Select `API Token Authentication` if your deployment requires it
+     - Or `No Authentication` if your server handles auth via environment variables
+
+4. **Connect and test**:
+   - Click `Connect`
+   - Once connected, enable it in a chat session
+   - Ask: "What Eulerian Marketing Platform capabilities do you have?"
+
+#### Security Recommendations for Remote Deployment
+
+- ✅ Always use HTTPS (not HTTP)
+- ✅ Implement rate limiting
+- ✅ Add request origin validation
+- ✅ Use environment variables for secrets (never hardcode)
+- ✅ Monitor server logs for unusual activity
+- ✅ Consider adding IP allowlisting if possible
+
+---
+
+## Usage Examples
+
+Once configured with any client, you can interact with your remote Eulerian Marketing Platform:
+
+```
+User: "What tools are available from Eulerian?"
+→ Proxy calls list_remote_tools() and returns all available tools
+
+User: "Call the get_campaigns tool"
+→ Proxy forwards to remote server and returns campaign data
+
+User: "Show me campaign details for CAMP-12345"
+→ Claude uses call_eulerian_tool() to fetch specific campaign
+
+User: "What resources are available?"
+→ Proxy lists all available data sources
+
+User: "Read the configuration at eulerian://config/settings"
+→ Proxy fetches and returns the configuration
+```
+
+The AI assistant will automatically use the appropriate proxy tools to fulfill your requests.
+
+### Viewing Logs
+
+Monitor proxy activity in real-time:
+
+```bash
+# Default log location
+tail -f /tmp/eulerian-mcp-proxy.log
+
+# Custom log location
+tail -f /var/log/eulerian-mcp-proxy.log
+```
+
+You'll see detailed logging of:
+- Requests to the remote server
+- HTTP responses and status codes
+- Tool calls and results
+- Errors and warnings
+
+## Troubleshooting
+
+### Common Issues
+
+#### "EMP_API_ENDPOINT environment variable is required"
+- **Solution**: Ensure you've set the `EMP_API_ENDPOINT` in your configuration
+- Check that there are no typos in the environment variable name
+
+#### "EMP_API_TOKEN environment variable is required"
+- **Solution**: Ensure you've set the `EMP_API_TOKEN` in your configuration
+- Verify your token is valid and hasn't expired
+
+#### Server not appearing in Claude Desktop
+- **Solution**: 
+  - Restart Claude Desktop completely
+  - Check the configuration file for JSON syntax errors
+  - Verify the file path in your config is correct
+  - Look at logs: 
+    - macOS: `~/Library/Logs/Claude/mcp-server-*.log`
+    - Windows: `%APPDATA%\Claude\logs\`
+
+#### Tools not showing in Gemini CLI
+- **Solution**:
+  - Use `/mcp` command to check server status
+  - Verify the settings.json is valid JSON
+  - Restart Gemini CLI
+
+#### Mistral connector fails to connect
+- **Solution**:
+  - Verify your server is publicly accessible via `curl https://your-server.com/mcp`
+  - Check server logs for errors
+  - Ensure you're using HTTPS (not HTTP)
+  - Verify the `/mcp` endpoint path is correct
+
+### Debug Mode
+
+For detailed debugging:
+
+```bash
+# Run with MCP Inspector
+npx @modelcontextprotocol/inspector uvx eulerian-marketing-platform
+
+# Or with environment variables
+EMP_API_ENDPOINT=your_endpoint EMP_API_TOKEN=your_token uvx eulerian-marketing-platform
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run with coverage
+pytest --cov=eulerian_marketing_platform
+```
+
+### Building from Source
+
+```bash
+# Clone the repository
+git clone https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp.git
+cd eulerian-marketing-platform-mcp
+
+# Install in development mode
+pip install -e .
+
+# Build distribution
+pip install build
+python -m build
+
+# This creates:
+# dist/eulerian_marketing_platform-0.1.0.tar.gz
+# dist/eulerian_marketing_platform-0.1.0-py3-none-any.whl
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+- **Issues**: https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp/issues
+- **Documentation**: https://github.com/EulerianTechnologies/eulerian-marketing-platform-mcp#readme
+- **Eulerian Technologies**: https://www.eulerian.com
+
+## Changelog
+
+### 0.1.0 (Initial Release)
+- Initial MCP server implementation
+- Support for Claude Desktop, Gemini CLI, and Mistral AI
+- Cross-platform support (Windows, Linux, macOS)
+- Environment-based configuration
+
+---
+
+**Note**: Replace all placeholder URLs and tokens with your actual Eulerian Marketing Platform credentials before use.

eulerian_marketing_platform-0.1.0.dist-info/RECORD

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

eulerian_marketing_platform-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eulerian_marketing_platform-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eulerian-marketing-platform = eulerian_marketing_platform.server:main

eulerian_marketing_platform-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eulerian_marketing_platform