eulerian-marketing-platform 0.1.2__py3-none-any.whl → 0.2.1__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.1"
 __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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eulerian-marketing-platform
-Version: 0.1.2
+Version: 0.2.1
 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
@@ -37,7 +36,7 @@ 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.
+A Model Context Protocol (MCP) **proxy server** that bridges AI assistants (Claude Desktop, Gemini CLI, etc ...) 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
 
@@ -62,12 +61,11 @@ The proxy:
 - **🔌 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
+- **🤖 Multiple AI clients**: Compatible with Claude Desktop and Gemini CLI
 - **📝 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
 
@@ -77,63 +75,18 @@ The proxy:
 - 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).
+All API Endpoints supported by the [Eulerian API](https://doc.api.eulerian.com) can be queried through the current MCP.
 
 ## 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)
-```
+The easiest way to use this MCP server is with `pip`.
 
-### Alternative: Install via pip
+### Install via pip
 
 If you prefer to install the package globally:
 
@@ -154,8 +107,8 @@ pip install -e .
 ### 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
+  - Example: `https://dem.api.eulerian.com/mcp`
+- `EMP_API_TOKEN`: Your authentication token for the remote server, it is the one linked to your Eulerian account.
 
 ### Optional Environment Variables
 
@@ -197,23 +150,6 @@ Claude Desktop supports local MCP servers via stdio transport.
 
 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": {
@@ -244,7 +180,6 @@ Claude Desktop supports local MCP servers via stdio transport.
 
 **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/`
@@ -285,8 +220,8 @@ nano ~/.gemini/settings.json
 {
   "mcpServers": {
     "eulerian-marketing-platform": {
-      "command": "uvx",
-      "args": ["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"
@@ -317,102 +252,6 @@ gemini
 
 ---
 
-### 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:
@@ -421,17 +260,14 @@ Once configured with any client, you can interact with your remote Eulerian Mark
 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: "Call the update_goal tool"
+→ Proxy forwards to remote server and update goal settings
 
 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.
@@ -481,13 +317,6 @@ You'll see detailed logging of:
   - 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:
@@ -556,9 +385,14 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## Changelog
 
+### 0.2.0
+- Move to full Proxy mode
+- Remove instructions for uvx deployment
+- Remove instructions for Mistral integration (too complex)
+
 ### 0.1.0 (Initial Release)
 - Initial MCP server implementation
-- Support for Claude Desktop, Gemini CLI, and Mistral AI
+- Support for Claude Desktop, Gemini CLI
 - Cross-platform support (Windows, Linux, macOS)
 - Environment-based configuration
 

eulerian_marketing_platform-0.2.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+eulerian_marketing_platform/__init__.py,sha256=HibL07V6VMhqFcQSFGJm8ogUu9Qcfl2SSenCfdKtBFY,428
+eulerian_marketing_platform/server.py,sha256=y1vy-LvSjG18dvDv65hO875s_7vogbb5bdNwTetKKcU,8335
+eulerian_marketing_platform-0.2.1.dist-info/LICENSE,sha256=eIqBqE_fRsqQJ8F-2v0e-8WzZqdshsCqnzmqLAWrNHU,1078
+eulerian_marketing_platform-0.2.1.dist-info/METADATA,sha256=WDzHWUPBn0P6MC3PhFXOx70BRGa2xGHIdwoycImLCaA,12111
+eulerian_marketing_platform-0.2.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+eulerian_marketing_platform-0.2.1.dist-info/entry_points.txt,sha256=rrPZptATSS9PUtH9gzCYq0WuP6eahkF-DkdUP1FaYfk,88
+eulerian_marketing_platform-0.2.1.dist-info/top_level.txt,sha256=nidh3T6fw-mLjUqZwQ8AiMScS4usuH0WXW4ZgG4HYCo,28
+eulerian_marketing_platform-0.2.1.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,,