Add streamable-http transport support

Author: ivnvxd

.env.example

@@ -40,4 +40,19 @@ ODOO_API_KEY=your-api-key-here
 
 # Maximum pagination limit (optional)
 # Maximum number of records that can be requested
-# ODOO_MCP_MAX_LIMIT=100
+# ODOO_MCP_MAX_LIMIT=100
+
+# Transport Configuration
+# =======================
+
+# Transport type (optional)
+# Valid values: stdio (default), streamable-http
+# ODOO_MCP_TRANSPORT=stdio
+
+# Server host for HTTP transport (optional)
+# Only used when transport is streamable-http
+# ODOO_MCP_HOST=localhost
+
+# Server port for HTTP transport (optional)
+# Only used when transport is streamable-http
+# ODOO_MCP_PORT=8000

CHANGELOG.md

@@ -5,10 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.1.2] - 2025-06-19
 
 ### Added
 - **Resource Discovery**: Added `list_resource_templates` tool to provide resource URI template information
+- **HTTP Transport**: Added streamable-http transport support for web and remote access
 
 ## [0.1.1] - 2025-06-16
 

README.md

@@ -191,6 +191,62 @@ The server requires the following environment variables:
 - If database listing is restricted on your server, you must specify `ODOO_DB`
 - API key authentication is recommended for better security
 
+### Transport Options
+
+The server supports multiple transport protocols for different use cases:
+
+#### 1. **stdio** (Default)
+Standard input/output transport - used by desktop AI applications like Claude Desktop.
+
+```bash
+# Default transport - no additional configuration needed
+uvx mcp-server-odoo
+```
+
+#### 2. **streamable-http**
+Standard HTTP transport for REST API-style access and remote connectivity.
+
+```bash
+# Run with HTTP transport
+uvx mcp-server-odoo --transport streamable-http --host 0.0.0.0 --port 8000
+
+# Or use environment variables
+export ODOO_MCP_TRANSPORT=streamable-http
+export ODOO_MCP_HOST=0.0.0.0
+export ODOO_MCP_PORT=8000
+uvx mcp-server-odoo
+```
+
+The HTTP endpoint will be available at: `http://localhost:8000/mcp/`
+
+> **Note**: SSE (Server-Sent Events) transport has been deprecated in MCP protocol version 2025-03-26. Use streamable-http transport instead for HTTP-based communication. Requires MCP library v1.9.4 or higher for proper session management.
+
+#### Transport Configuration
+
+| Variable/Flag | Description | Default |
+|--------------|-------------|---------|
+| `ODOO_MCP_TRANSPORT` / `--transport` | Transport type: stdio, streamable-http | `stdio` |
+| `ODOO_MCP_HOST` / `--host` | Host to bind for HTTP transports | `localhost` |
+| `ODOO_MCP_PORT` / `--port` | Port to bind for HTTP transports | `8000` |
+
+**Example: Running streamable-http transport for remote access**
+
+```json
+{
+  "mcpServers": {
+    "odoo-remote": {
+      "command": "uvx",
+      "args": ["mcp-server-odoo", "--transport", "streamable-http", "--port", "8080"],
+      "env": {
+        "ODOO_URL": "https://your-odoo-instance.com",
+        "ODOO_API_KEY": "your-api-key-here",
+        "ODOO_DB": "your-database-name"
+      }
+    }
+  }
+}
+```
+
 ### Setting up Odoo
 
 1. **Install the MCP module**:
@@ -450,6 +506,34 @@ npx @modelcontextprotocol/inspector python -m mcp_server_odoo
 ```
 </details>
 
+## Testing
+
+### Transport Tests
+
+You can test both stdio and streamable-http transports to ensure they're working correctly:
+
+```bash
+# Run comprehensive transport tests
+python tests/run_transport_tests.py
+```
+
+This will test:
+- **stdio transport**: Basic initialization and communication
+- **streamable-http transport**: HTTP endpoint, session management, and tool calls
+
+### Unit Tests
+
+For complete testing including unit and integration tests:
+
+```bash
+# Run all tests
+uv run pytest --cov
+
+# Run specific test categories
+uv run pytest tests/test_tools.py -v
+uv run pytest tests/test_server_foundation.py -v
+```
+
 ## License
 
 This project is licensed under the Mozilla Public License 2.0 (MPL-2.0) - see the [LICENSE](LICENSE) file for details.

mcp_server_odoo/__main__.py

@@ -4,8 +4,10 @@
 Odoo MCP server via uvx or direct execution.
 """
 
+import argparse
 import asyncio
 import logging
+import os
 import sys
 from typing import Optional
 
@@ -19,7 +21,7 @@ def main(argv: Optional[list[str]] = None) -> int:
     """Main entry point for the MCP server.
 
     This function handles command-line arguments, loads configuration,
-    and runs the MCP server with stdio transport.
+    and runs the MCP server with the specified transport.
 
     Args:
         argv: Command line arguments (defaults to sys.argv[1:])
@@ -30,48 +32,79 @@ def main(argv: Optional[list[str]] = None) -> int:
     # Load environment variables from .env file
     load_dotenv()
 
-    # Parse command line arguments
-    if argv is None:
-        argv = sys.argv[1:]
-
-    # Handle help flag
-    if "--help" in argv or "-h" in argv:
-        print("Odoo MCP Server - Model Context Protocol server for Odoo ERP", file=sys.stderr)
-        print("\nUsage: mcp-server-odoo [options]", file=sys.stderr)
-        print("\nOptions:", file=sys.stderr)
-        print("  -h, --help         Show this help message and exit", file=sys.stderr)
-        print("  --version          Show version information", file=sys.stderr)
-        print("\nEnvironment variables:", file=sys.stderr)
-        print("  ODOO_URL           Odoo server URL (required)", file=sys.stderr)
-        print("  ODOO_API_KEY       Odoo API key (preferred authentication)", file=sys.stderr)
-        print("  ODOO_USER          Odoo username (fallback if no API key)", file=sys.stderr)
-        print("  ODOO_PASSWORD      Odoo password (required with username)", file=sys.stderr)
-        print("  ODOO_DB            Odoo database name (auto-detected if not set)", file=sys.stderr)
-        print("\nOptional environment variables:", file=sys.stderr)
-        print("  ODOO_MCP_LOG_LEVEL    Log level (DEBUG, INFO, WARNING, ERROR)", file=sys.stderr)
-        print("  ODOO_MCP_DEFAULT_LIMIT Default record limit (default: 10)", file=sys.stderr)
-        print("  ODOO_MCP_MAX_LIMIT     Maximum record limit (default: 100)", file=sys.stderr)
-        print(
-            "\nFor more information, visit: https://github.com/ivnvxd/mcp-server-odoo",
-            file=sys.stderr,
-        )
-        return 0
-
-    # Handle version flag
-    if "--version" in argv:
-        print(f"odoo-mcp-server v{SERVER_VERSION}", file=sys.stderr)
-        return 0
+    # Create argument parser
+    parser = argparse.ArgumentParser(
+        description="Odoo MCP Server - Model Context Protocol server for Odoo ERP",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""Environment variables:
+  ODOO_URL           Odoo server URL (required)
+  ODOO_API_KEY       Odoo API key (preferred authentication)
+  ODOO_USER          Odoo username (fallback if no API key)
+  ODOO_PASSWORD      Odoo password (required with username)
+  ODOO_DB            Odoo database name (auto-detected if not set)
+
+Optional environment variables:
+  ODOO_MCP_LOG_LEVEL    Log level (DEBUG, INFO, WARNING, ERROR)
+  ODOO_MCP_DEFAULT_LIMIT Default record limit (default: 10)
+  ODOO_MCP_MAX_LIMIT     Maximum record limit (default: 100)
+  ODOO_MCP_TRANSPORT     Transport type: stdio or streamable-http (default: stdio)
+  ODOO_MCP_HOST          Server host for HTTP transports (default: localhost)
+  ODOO_MCP_PORT          Server port for HTTP transports (default: 8000)
+
+For more information, visit: https://github.com/ivnvxd/mcp-server-odoo""",
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"odoo-mcp-server v{SERVER_VERSION}",
+    )
+
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "streamable-http"],
+        default=os.getenv("ODOO_MCP_TRANSPORT", "stdio"),
+        help="Transport type to use (default: stdio)",
+    )
+
+    parser.add_argument(
+        "--host",
+        default=os.getenv("ODOO_MCP_HOST", "localhost"),
+        help="Server host for HTTP transports (default: localhost)",
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=int(os.getenv("ODOO_MCP_PORT", "8000")),
+        help="Server port for HTTP transports (default: 8000)",
+    )
+
+    # Parse arguments
+    args = parser.parse_args(argv)
 
     try:
+        # Override environment variables with CLI arguments
+        if args.transport:
+            os.environ["ODOO_MCP_TRANSPORT"] = args.transport
+        if args.host:
+            os.environ["ODOO_MCP_HOST"] = args.host
+        if args.port:
+            os.environ["ODOO_MCP_PORT"] = str(args.port)
+
         # Load configuration from environment
         config = load_config()
 
         # Create server instance
         server = OdooMCPServer(config)
 
-        # Run the server with stdio transport
-        # This is the standard way to run MCP servers with uvx
-        asyncio.run(server.run_stdio())
+        # Run the server with the specified transport
+        if config.transport == "stdio":
+            asyncio.run(server.run_stdio())
+        elif config.transport == "streamable-http":
+            asyncio.run(server.run_http(host=config.host, port=config.port))
+        else:
+            raise ValueError(f"Unsupported transport: {config.transport}")
 
         return 0
 

mcp_server_odoo/config.py

@@ -7,7 +7,7 @@
 import os
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Literal, Optional
 
 from dotenv import load_dotenv
 
@@ -30,6 +30,11 @@ class OdooConfig:
     default_limit: int = 10
     max_limit: int = 100
 
+    # MCP transport configuration
+    transport: Literal["stdio", "streamable-http"] = "stdio"
+    host: str = "localhost"
+    port: int = 8000
+
     def __post_init__(self):
         """Validate configuration after initialization."""
         # Validate URL
@@ -68,6 +73,18 @@ def __post_init__(self):
                 f"Must be one of: {', '.join(valid_log_levels)}"
             )
 
+        # Validate transport
+        valid_transports = {"stdio", "streamable-http"}
+        if self.transport not in valid_transports:
+            raise ValueError(
+                f"Invalid transport: {self.transport}. "
+                f"Must be one of: {', '.join(valid_transports)}"
+            )
+
+        # Validate port
+        if self.port <= 0 or self.port > 65535:
+            raise ValueError("Port must be between 1 and 65535")
+
     @property
     def uses_api_key(self) -> bool:
         """Check if configuration uses API key authentication."""
@@ -144,6 +161,9 @@ def get_int_env(key: str, default: int) -> int:
         log_level=os.getenv("ODOO_MCP_LOG_LEVEL", "INFO").strip(),
         default_limit=get_int_env("ODOO_MCP_DEFAULT_LIMIT", 10),
         max_limit=get_int_env("ODOO_MCP_MAX_LIMIT", 100),
+        transport=os.getenv("ODOO_MCP_TRANSPORT", "stdio").strip(),
+        host=os.getenv("ODOO_MCP_HOST", "localhost").strip(),
+        port=get_int_env("ODOO_MCP_PORT", 8000),
     )
 
     return config

mcp_server_odoo/server.py

@@ -59,7 +59,6 @@ def __init__(self, config: Optional[OdooConfig] = None):
         # Create FastMCP instance with server metadata
         self.app = FastMCP(
             name="odoo-mcp-server",
-            version=SERVER_VERSION,
             instructions="MCP server for accessing and managing Odoo ERP data through the Model Context Protocol",
         )
 
@@ -182,6 +181,46 @@ def run_stdio_sync(self):
 
         asyncio.run(self.run_stdio())
 
+    # SSE transport has been deprecated in MCP protocol version 2025-03-26
+    # Use streamable-http transport instead
+
+    async def run_http(self, host: str = "localhost", port: int = 8000):
+        """Run the server using streamable HTTP transport.
+
+        Args:
+            host: Host to bind to
+            port: Port to bind to
+        """
+        try:
+            # Establish connection before starting server
+            with perf_logger.track_operation("server_startup"):
+                self._ensure_connection()
+
+                # Register resources after connection is established
+                self._register_resources()
+                self._register_tools()
+
+            logger.info(f"Starting MCP server with HTTP transport on {host}:{port}...")
+
+            # Update FastMCP settings for host and port
+            self.app.settings.host = host
+            self.app.settings.port = port
+
+            # Use the specific streamable HTTP async method
+            await self.app.run_streamable_http_async()
+
+        except KeyboardInterrupt:
+            logger.info("Server interrupted by user")
+        except (OdooConnectionError, ConfigurationError):
+            # Let these specific errors propagate
+            raise
+        except Exception as e:
+            context = ErrorContext(operation="server_run_http")
+            error_handler.handle_error(e, context=context)
+        finally:
+            # Always cleanup connection
+            self._cleanup_connection()
+
     def get_capabilities(self) -> Dict[str, Dict[str, bool]]:
         """Get server capabilities.
 

pyproject.toml

@@ -30,7 +30,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "mcp>=1.9.2",
+    "mcp>=1.9.4",
     "httpx>=0.27.0",
     "python-dotenv>=1.0.0",
     "pydantic>=2.0.0",