mseep-odoo-mcp 0.0.3__py3-none-any.whl

mseep_odoo_mcp-0.0.3.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: mseep-odoo-mcp
+Version: 0.0.3
+Summary: MCP Server for Odoo Integration
+Home-page: 
+Author: mseep
+Author-email: Lê Anh Tuấn <justin.le.1105@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/tuanle96/mcp-odoo
+Project-URL: Issues, https://github.com/tuanle96/mcp-odoo/issues
+Keywords: odoo,mcp,server
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=0.1.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: xmlrpc>=0.4.1
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# Odoo MCP Server
+
+An MCP server implementation that integrates with Odoo ERP systems, enabling AI assistants to interact with Odoo data and functionality through the Model Context Protocol.
+
+## Features
+
+* **Comprehensive Odoo Integration**: Full access to Odoo models, records, and methods
+* **XML-RPC Communication**: Secure connection to Odoo instances via XML-RPC
+* **Flexible Configuration**: Support for config files and environment variables
+* **Resource Pattern System**: URI-based access to Odoo data structures
+* **Error Handling**: Clear error messages for common Odoo API issues
+* **Stateless Operations**: Clean request/response cycle for reliable integration
+
+## Tools
+
+* **search_records**
+  * Search for records in any Odoo model
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+    * `domain` (array): Search domain (e.g., [['is_company', '=', true]])
+    * `fields` (optional array): Optional fields to fetch
+    * `limit` (optional number): Maximum number of records to return
+  * Returns: Matching records with requested fields
+
+* **read_record**
+  * Read details of a specific record
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+    * `id` (number): The record ID
+    * `fields` (optional array): Optional fields to fetch
+  * Returns: Record data with requested fields
+
+* **create_record**
+  * Create a new record in Odoo
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+    * `values` (object): Dictionary of field values
+  * Returns: Dictionary with the new record ID
+
+* **update_record**
+  * Update an existing record
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+    * `id` (number): The record ID
+    * `values` (object): Dictionary of field values to update
+  * Returns: Dictionary indicating success
+
+* **delete_record**
+  * Delete a record from Odoo
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+    * `id` (number): The record ID
+  * Returns: Dictionary indicating success
+
+* **execute_method**
+  * Execute a custom method on an Odoo model
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+    * `method` (string): Method name to execute
+    * `args` (optional array): Positional arguments
+    * `kwargs` (optional object): Keyword arguments
+  * Returns: Dictionary with the method result
+
+* **get_model_fields**
+  * Get field definitions for a model
+  * Inputs:
+    * `model` (string): The model name (e.g., 'res.partner')
+  * Returns: Dictionary with field definitions
+
+* **search_employee**
+  * Search for employees by name.
+  * Inputs:
+    * `name` (string): The name (or part of the name) to search for.
+    * `limit` (optional number): The maximum number of results to return (default 20).
+  * Returns: List of matching employee names and IDs.
+
+* **search_holidays**
+  * Searches for holidays within a specified date range.
+  * Inputs:
+    * `start_date` (string): Start date in YYYY-MM-DD format.
+    * `end_date` (string): End date in YYYY-MM-DD format.
+    * `employee_id` (optional number): Optional employee ID to filter holidays.
+  * Returns: List of holidays found.
+
+## Resources
+
+* **odoo://models**
+  * Lists all available models in the Odoo system
+  * Returns: JSON array of model information
+
+* **odoo://model/{model_name}**
+  * Get information about a specific model including fields
+  * Example: `odoo://model/res.partner`
+  * Returns: JSON object with model metadata and field definitions
+
+* **odoo://record/{model_name}/{record_id}**
+  * Get a specific record by ID
+  * Example: `odoo://record/res.partner/1`
+  * Returns: JSON object with record data
+
+* **odoo://search/{model_name}/{domain}**
+  * Search for records that match a domain
+  * Example: `odoo://search/res.partner/[["is_company","=",true]]`
+  * Returns: JSON array of matching records (limited to 10 by default)
+
+## Configuration
+
+### Odoo Connection Setup
+
+1. Create a configuration file named `odoo_config.json`:
+
+```json
+{
+  "url": "https://your-odoo-instance.com",
+  "db": "your-database-name",
+  "username": "your-username",
+  "password": "your-password-or-api-key"
+}
+```
+
+2. Alternatively, use environment variables:
+   * `ODOO_URL`: Your Odoo server URL
+   * `ODOO_DB`: Database name
+   * `ODOO_USERNAME`: Login username
+   * `ODOO_PASSWORD`: Password or API key
+   * `ODOO_TIMEOUT`: Connection timeout in seconds (default: 30)
+   * `ODOO_VERIFY_SSL`: Whether to verify SSL certificates (default: true)
+   * `HTTP_PROXY`: Force the ODOO connection to use an HTTP proxy
+
+### Usage with Claude Desktop
+
+Add this to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "odoo": {
+      "command": "python",
+      "args": [
+        "-m",
+        "odoo_mcp"
+      ],
+      "env": {
+        "ODOO_URL": "https://your-odoo-instance.com",
+        "ODOO_DB": "your-database-name",
+        "ODOO_USERNAME": "your-username",
+        "ODOO_PASSWORD": "your-password-or-api-key"
+      }
+    }
+  }
+}
+```
+
+### Docker
+
+```json
+{
+  "mcpServers": {
+    "odoo": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e",
+        "ODOO_URL",
+        "-e",
+        "ODOO_DB",
+        "-e",
+        "ODOO_USERNAME",
+        "-e",
+        "ODOO_PASSWORD",
+        "mcp/odoo"
+      ],
+      "env": {
+        "ODOO_URL": "https://your-odoo-instance.com",
+        "ODOO_DB": "your-database-name",
+        "ODOO_USERNAME": "your-username",
+        "ODOO_PASSWORD": "your-password-or-api-key"
+      }
+    }
+  }
+}
+```
+
+## Installation
+
+### Python Package
+
+```bash
+pip install odoo-mcp
+```
+
+### Running the Server
+
+```bash
+# Using the installed package
+odoo-mcp
+
+# Using the MCP development tools
+mcp dev odoo_mcp/server.py
+
+# With additional dependencies
+mcp dev odoo_mcp/server.py --with pandas --with numpy
+
+# Mount local code for development
+mcp dev odoo_mcp/server.py --with-editable .
+```
+
+## Build
+
+Docker build:
+
+```bash
+docker build -t mcp/odoo:latest -f Dockerfile .
+```
+
+## Parameter Formatting Guidelines
+
+When using the MCP tools for Odoo, pay attention to these parameter formatting guidelines:
+
+1. **Domain Parameter**:
+   * The following domain formats are supported:
+     * List format: `[["field", "operator", value], ...]`
+     * Object format: `{"conditions": [{"field": "...", "operator": "...", "value": "..."}]}`
+     * JSON string of either format
+   * Examples:
+     * List format: `[["is_company", "=", true]]`
+     * Object format: `{"conditions": [{"field": "date_order", "operator": ">=", "value": "2025-03-01"}]}`
+     * Multiple conditions: `[["date_order", ">=", "2025-03-01"], ["date_order", "<=", "2025-03-31"]]`
+
+2. **Fields Parameter**:
+   * Should be an array of field names: `["name", "email", "phone"]`
+   * The server will try to parse string inputs as JSON
+
+## License
+
+This MCP server is licensed under the MIT License.

mseep_odoo_mcp-0.0.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+mseep_odoo_mcp-0.0.3.dist-info/licenses/LICENSE,sha256=_FwB4PGxcQWsToTqX33moF0HqnB45Ox6Fr0VPJiLyBI,1071
+odoo_mcp/__init__.py,sha256=fw0VD6ow8QmzQ4L8DxyneEMqC6bgAEde62nvEUqiGgQ,102
+odoo_mcp/__main__.py,sha256=H_46LG58iV38bLXANKQW-Hzi5iQ7Ww34RtgIVe3YMHk,1834
+odoo_mcp/odoo_client.py,sha256=tmZs_keeuRBQ77pPHpJ4f4wVCTjhZeahLZ_rZIAruNQ,14699
+odoo_mcp/server.py,sha256=f5ukjDgYLTN4wL96xJWTyoMak6qF-LV6AO8bYs16PvA,14995
+mseep_odoo_mcp-0.0.3.dist-info/METADATA,sha256=REwngGo1B5exHphpV8TCWgtmqZklbniZIVN2wj4VjtU,7884
+mseep_odoo_mcp-0.0.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mseep_odoo_mcp-0.0.3.dist-info/entry_points.txt,sha256=VAFapQ2i2fiMrM5fRcxVz1c9M3j-5RZ6QCJJT6taxQk,52
+mseep_odoo_mcp-0.0.3.dist-info/top_level.txt,sha256=U9N8tvrkBgl0wl-xe8OmrJhxfpOdynRAVA7XFJIi7rk,9
+mseep_odoo_mcp-0.0.3.dist-info/RECORD,,

mseep_odoo_mcp-0.0.3.dist-info/WHEEL

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

mseep_odoo_mcp-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+odoo-mcp = odoo_mcp.__main__:main

mseep_odoo_mcp-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lê Anh Tuấn
+
+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.

mseep_odoo_mcp-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+odoo_mcp

odoo_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""
+Odoo MCP Server - MCP Server for Odoo Integration
+"""
+
+from .server import mcp
+
+__all__ = ["mcp"]

odoo_mcp/__main__.py

@@ -0,0 +1,54 @@
+"""
+Command line entry point for the Odoo MCP Server
+"""
+import sys
+import asyncio
+import traceback
+import os
+
+from .server import mcp
+
+
+def main() -> int:
+    """
+    Run the MCP server
+    """
+    try:
+        print("=== ODOO MCP SERVER STARTING ===", file=sys.stderr)
+        print(f"Python version: {sys.version}", file=sys.stderr)
+        print("Environment variables:", file=sys.stderr)
+        for key, value in os.environ.items():
+            if key.startswith("ODOO_"):
+                if key == "ODOO_PASSWORD":
+                    print(f"  {key}: ***hidden***", file=sys.stderr)
+                else:
+                    print(f"  {key}: {value}", file=sys.stderr)
+        
+        # Check if server instance has the run_stdio method
+        methods = [method for method in dir(mcp) if not method.startswith('_')]
+        print(f"Available methods on mcp object: {methods}", file=sys.stderr)
+        
+        print("Starting MCP server with run() method...", file=sys.stderr)
+        sys.stderr.flush()  # Ensure log information is written immediately
+        
+        # Use the run() method directly
+        mcp.run()
+        
+        # If execution reaches here, the server exited normally
+        print("MCP server stopped normally", file=sys.stderr)
+        return 0
+    except KeyboardInterrupt:
+        print("MCP server stopped by user", file=sys.stderr)
+        return 0
+    except Exception as e:
+        print(f"Error starting server: {e}", file=sys.stderr)
+        print("Exception details:", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        print("\nServer object information:", file=sys.stderr)
+        print(f"MCP object type: {type(mcp)}", file=sys.stderr)
+        print(f"MCP object dir: {dir(mcp)}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

odoo_mcp/odoo_client.py

@@ -0,0 +1,446 @@
+"""
+Odoo XML-RPC client for MCP server integration
+"""
+
+import json
+import os
+import re
+import socket
+import urllib.parse
+
+import http.client
+import xmlrpc.client
+
+
+class OdooClient:
+    """Client for interacting with Odoo via XML-RPC"""
+
+    def __init__(
+        self,
+        url,
+        db,
+        username,
+        password,
+        timeout=10,
+        verify_ssl=True,
+    ):
+        """
+        Initialize the Odoo client with connection parameters
+
+        Args:
+            url: Odoo server URL (with or without protocol)
+            db: Database name
+            username: Login username
+            password: Login password
+            timeout: Connection timeout in seconds
+            verify_ssl: Whether to verify SSL certificates
+        """
+        # Ensure URL has a protocol
+        if not re.match(r"^https?://", url):
+            url = f"http://{url}"
+
+        # Remove trailing slash from URL if present
+        url = url.rstrip("/")
+
+        self.url = url
+        self.db = db
+        self.username = username
+        self.password = password
+        self.uid = None
+
+        # Set timeout and SSL verification
+        self.timeout = timeout
+        self.verify_ssl = verify_ssl
+
+        # Setup connections
+        self._common = None
+        self._models = None
+
+        # Parse hostname for logging
+        parsed_url = urllib.parse.urlparse(self.url)
+        self.hostname = parsed_url.netloc
+
+        # Connect
+        self._connect()
+
+    def _connect(self):
+        """Initialize the XML-RPC connection and authenticate"""
+        # Tạo transport với timeout phù hợp
+        is_https = self.url.startswith("https://")
+        transport = RedirectTransport(
+            timeout=self.timeout, use_https=is_https, verify_ssl=self.verify_ssl
+        )
+
+        print(f"Connecting to Odoo at: {self.url}", file=os.sys.stderr)
+        print(f"  Hostname: {self.hostname}", file=os.sys.stderr)
+        print(
+            f"  Timeout: {self.timeout}s, Verify SSL: {self.verify_ssl}",
+            file=os.sys.stderr,
+        )
+
+        # Thiết lập endpoints
+        self._common = xmlrpc.client.ServerProxy(
+            f"{self.url}/xmlrpc/2/common", transport=transport
+        )
+        self._models = xmlrpc.client.ServerProxy(
+            f"{self.url}/xmlrpc/2/object", transport=transport
+        )
+
+        # Xác thực và lấy user ID
+        print(
+            f"Authenticating with database: {
+                self.db}, username: {self.username}",
+            file=os.sys.stderr,
+        )
+        try:
+            print(
+                f"Making request to {
+                    self.hostname}/xmlrpc/2/common (attempt 1)",
+                file=os.sys.stderr,
+            )
+            self.uid = self._common.authenticate(
+                self.db, self.username, self.password, {}
+            )
+            if not self.uid:
+                raise ValueError(
+                    "Authentication failed: Invalid username or password")
+        except (socket.error, socket.timeout, ConnectionError, TimeoutError) as e:
+            print(f"Connection error: {str(e)}", file=os.sys.stderr)
+            raise ConnectionError(
+                f"Failed to connect to Odoo server: {str(e)}")
+        except Exception as e:
+            print(f"Authentication error: {str(e)}", file=os.sys.stderr)
+            raise ValueError(f"Failed to authenticate with Odoo: {str(e)}")
+
+    def _execute(self, model, method, *args, **kwargs):
+        """Execute a method on an Odoo model"""
+        return self._models.execute_kw(
+            self.db, self.uid, self.password, model, method, args, kwargs
+        )
+
+    def execute_method(self, model, method, *args, **kwargs):
+        """
+        Execute an arbitrary method on a model
+
+        Args:
+            model: The model name (e.g., 'res.partner')
+            method: Method name to execute
+            *args: Positional arguments to pass to the method
+            **kwargs: Keyword arguments to pass to the method
+
+        Returns:
+            Result of the method execution
+        """
+        return self._execute(model, method, *args, **kwargs)
+
+    def get_models(self):
+        """
+        Get a list of all available models in the system
+
+        Returns:
+            List of model names
+
+        Examples:
+            >>> client = OdooClient(url, db, username, password)
+            >>> models = client.get_models()
+            >>> print(len(models))
+            125
+            >>> print(models[:5])
+            ['res.partner', 'res.users', 'res.company', 'res.groups', 'ir.model']
+        """
+        try:
+            # First search for model IDs
+            model_ids = self._execute("ir.model", "search", [])
+
+            if not model_ids:
+                return {
+                    "model_names": [],
+                    "models_details": {},
+                    "error": "No models found",
+                }
+
+            # Then read the model data with only the most basic fields
+            # that are guaranteed to exist in all Odoo versions
+            result = self._execute(
+                "ir.model", "read", model_ids, ["model", "name"])
+
+            # Extract and sort model names alphabetically
+            models = sorted([rec["model"] for rec in result])
+
+            # For more detailed information, include the full records
+            models_info = {
+                "model_names": models,
+                "models_details": {
+                    rec["model"]: {"name": rec.get("name", "")} for rec in result
+                },
+            }
+
+            return models_info
+        except Exception as e:
+            print(f"Error retrieving models: {str(e)}", file=os.sys.stderr)
+            return {"model_names": [], "models_details": {}, "error": str(e)}
+
+    def get_model_info(self, model_name):
+        """
+        Get information about a specific model
+
+        Args:
+            model_name: Name of the model (e.g., 'res.partner')
+
+        Returns:
+            Dictionary with model information
+
+        Examples:
+            >>> client = OdooClient(url, db, username, password)
+            >>> info = client.get_model_info('res.partner')
+            >>> print(info['name'])
+            'Contact'
+        """
+        try:
+            result = self._execute(
+                "ir.model",
+                "search_read",
+                [("model", "=", model_name)],
+                {"fields": ["name", "model"]},
+            )
+
+            if not result:
+                return {"error": f"Model {model_name} not found"}
+
+            return result[0]
+        except Exception as e:
+            print(f"Error retrieving model info: {str(e)}", file=os.sys.stderr)
+            return {"error": str(e)}
+
+    def get_model_fields(self, model_name):
+        """
+        Get field definitions for a specific model
+
+        Args:
+            model_name: Name of the model (e.g., 'res.partner')
+
+        Returns:
+            Dictionary mapping field names to their definitions
+
+        Examples:
+            >>> client = OdooClient(url, db, username, password)
+            >>> fields = client.get_model_fields('res.partner')
+            >>> print(fields['name']['type'])
+            'char'
+        """
+        try:
+            fields = self._execute(model_name, "fields_get")
+            return fields
+        except Exception as e:
+            print(f"Error retrieving fields: {str(e)}", file=os.sys.stderr)
+            return {"error": str(e)}
+
+    def search_read(
+        self, model_name, domain, fields=None, offset=None, limit=None, order=None
+    ):
+        """
+        Search for records and read their data in a single call
+
+        Args:
+            model_name: Name of the model (e.g., 'res.partner')
+            domain: Search domain (e.g., [('is_company', '=', True)])
+            fields: List of field names to return (None for all)
+            offset: Number of records to skip
+            limit: Maximum number of records to return
+            order: Sorting criteria (e.g., 'name ASC, id DESC')
+
+        Returns:
+            List of dictionaries with the matching records
+
+        Examples:
+            >>> client = OdooClient(url, db, username, password)
+            >>> records = client.search_read('res.partner', [('is_company', '=', True)], limit=5)
+            >>> print(len(records))
+            5
+        """
+        try:
+            kwargs = {}
+            if offset:
+                kwargs["offset"] = offset
+            if fields is not None:
+                kwargs["fields"] = fields
+            if limit is not None:
+                kwargs["limit"] = limit
+            if order is not None:
+                kwargs["order"] = order
+
+            result = self._execute(model_name, "search_read", domain, kwargs)
+            return result
+        except Exception as e:
+            print(f"Error in search_read: {str(e)}", file=os.sys.stderr)
+            return []
+
+    def read_records(self, model_name, ids, fields=None):
+        """
+        Read data of records by IDs
+
+        Args:
+            model_name: Name of the model (e.g., 'res.partner')
+            ids: List of record IDs to read
+            fields: List of field names to return (None for all)
+
+        Returns:
+            List of dictionaries with the requested records
+
+        Examples:
+            >>> client = OdooClient(url, db, username, password)
+            >>> records = client.read_records('res.partner', [1])
+            >>> print(records[0]['name'])
+            'YourCompany'
+        """
+        try:
+            kwargs = {}
+            if fields is not None:
+                kwargs["fields"] = fields
+
+            result = self._execute(model_name, "read", ids, kwargs)
+            return result
+        except Exception as e:
+            print(f"Error reading records: {str(e)}", file=os.sys.stderr)
+            return []
+
+
+class RedirectTransport(xmlrpc.client.Transport):
+    """Transport that adds timeout, SSL verification, and redirect handling"""
+
+    def __init__(
+        self, timeout=10, use_https=True, verify_ssl=True, max_redirects=5, proxy=None
+    ):
+        super().__init__()
+        self.timeout = timeout
+        self.use_https = use_https
+        self.verify_ssl = verify_ssl
+        self.max_redirects = max_redirects
+        self.proxy = proxy or os.environ.get("HTTP_PROXY")
+
+        if use_https and not verify_ssl:
+            import ssl
+
+            self.context = ssl._create_unverified_context()
+
+    def make_connection(self, host):
+        if self.proxy:
+            proxy_url = urllib.parse.urlparse(self.proxy)
+            connection = http.client.HTTPConnection(
+                proxy_url.hostname, proxy_url.port, timeout=self.timeout
+            )
+            connection.set_tunnel(host)
+        else:
+            if self.use_https and not self.verify_ssl:
+                connection = http.client.HTTPSConnection(
+                    host, timeout=self.timeout, context=self.context
+                )
+            else:
+                if self.use_https:
+                    connection = http.client.HTTPSConnection(
+                        host, timeout=self.timeout)
+                else:
+                    connection = http.client.HTTPConnection(
+                        host, timeout=self.timeout)
+
+        return connection
+
+    def request(self, host, handler, request_body, verbose):
+        """Send HTTP request with retry for redirects"""
+        redirects = 0
+        while redirects < self.max_redirects:
+            try:
+                print(f"Making request to {host}{handler}", file=os.sys.stderr)
+                return super().request(host, handler, request_body, verbose)
+            except xmlrpc.client.ProtocolError as err:
+                if err.errcode in (301, 302, 303, 307, 308) and err.headers.get(
+                    "location"
+                ):
+                    redirects += 1
+                    location = err.headers.get("location")
+                    parsed = urllib.parse.urlparse(location)
+                    if parsed.netloc:
+                        host = parsed.netloc
+                    handler = parsed.path
+                    if parsed.query:
+                        handler += "?" + parsed.query
+                else:
+                    raise
+            except Exception as e:
+                print(f"Error during request: {str(e)}", file=os.sys.stderr)
+                raise
+
+        raise xmlrpc.client.ProtocolError(
+            host + handler, 310, "Too many redirects", {})
+
+
+def load_config():
+    """
+    Load Odoo configuration from environment variables or config file
+
+    Returns:
+        dict: Configuration dictionary with url, db, username, password
+    """
+    # Define config file paths to check
+    config_paths = [
+        "./odoo_config.json",
+        os.path.expanduser("~/.config/odoo/config.json"),
+        os.path.expanduser("~/.odoo_config.json"),
+    ]
+
+    # Try environment variables first
+    if all(
+        var in os.environ
+        for var in ["ODOO_URL", "ODOO_DB", "ODOO_USERNAME", "ODOO_PASSWORD"]
+    ):
+        return {
+            "url": os.environ["ODOO_URL"],
+            "db": os.environ["ODOO_DB"],
+            "username": os.environ["ODOO_USERNAME"],
+            "password": os.environ["ODOO_PASSWORD"],
+        }
+
+    # Try to load from file
+    for path in config_paths:
+        expanded_path = os.path.expanduser(path)
+        if os.path.exists(expanded_path):
+            with open(expanded_path, "r") as f:
+                return json.load(f)
+
+    raise FileNotFoundError(
+        "No Odoo configuration found. Please create an odoo_config.json file or set environment variables."
+    )
+
+
+def get_odoo_client():
+    """
+    Get a configured Odoo client instance
+
+    Returns:
+        OdooClient: A configured Odoo client instance
+    """
+    config = load_config()
+
+    # Get additional options from environment variables
+    timeout = int(
+        os.environ.get("ODOO_TIMEOUT", "30")
+    )  # Increase default timeout to 30 seconds
+    verify_ssl = os.environ.get("ODOO_VERIFY_SSL", "1").lower() in [
+        "1", "true", "yes"]
+
+    # Print detailed configuration
+    print("Odoo client configuration:", file=os.sys.stderr)
+    print(f"  URL: {config['url']}", file=os.sys.stderr)
+    print(f"  Database: {config['db']}", file=os.sys.stderr)
+    print(f"  Username: {config['username']}", file=os.sys.stderr)
+    print(f"  Timeout: {timeout}s", file=os.sys.stderr)
+    print(f"  Verify SSL: {verify_ssl}", file=os.sys.stderr)
+
+    return OdooClient(
+        url=config["url"],
+        db=config["db"],
+        username=config["username"],
+        password=config["password"],
+        timeout=timeout,
+        verify_ssl=verify_ssl,
+    )

odoo_mcp/server.py

@@ -0,0 +1,444 @@
+"""
+MCP server for Odoo integration
+
+Provides MCP tools and resources for interacting with Odoo ERP systems
+"""
+
+import json
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Any, AsyncIterator, Dict, List, Optional, Union, cast
+
+from mcp.server.fastmcp import Context, FastMCP
+from pydantic import BaseModel, Field
+
+from .odoo_client import OdooClient, get_odoo_client
+
+
+@dataclass
+class AppContext:
+    """Application context for the MCP server"""
+
+    odoo: OdooClient
+
+
+@asynccontextmanager
+async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
+    """
+    Application lifespan for initialization and cleanup
+    """
+    # Initialize Odoo client on startup
+    odoo_client = get_odoo_client()
+
+    try:
+        yield AppContext(odoo=odoo_client)
+    finally:
+        # No cleanup needed for Odoo client
+        pass
+
+
+# Create MCP server
+mcp = FastMCP(
+    "Odoo MCP Server",
+    description="MCP Server for interacting with Odoo ERP systems",
+    dependencies=["requests"],
+    lifespan=app_lifespan,
+)
+
+
+# ----- MCP Resources -----
+
+
+@mcp.resource(
+    "odoo://models", description="List all available models in the Odoo system"
+)
+def get_models() -> str:
+    """Lists all available models in the Odoo system"""
+    odoo_client = get_odoo_client()
+    models = odoo_client.get_models()
+    return json.dumps(models, indent=2)
+
+
+@mcp.resource(
+    "odoo://model/{model_name}",
+    description="Get detailed information about a specific model including fields",
+)
+def get_model_info(model_name: str) -> str:
+    """
+    Get information about a specific model
+
+    Parameters:
+        model_name: Name of the Odoo model (e.g., 'res.partner')
+    """
+    odoo_client = get_odoo_client()
+    try:
+        # Get model info
+        model_info = odoo_client.get_model_info(model_name)
+
+        # Get field definitions
+        fields = odoo_client.get_model_fields(model_name)
+        model_info["fields"] = fields
+
+        return json.dumps(model_info, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+@mcp.resource(
+    "odoo://record/{model_name}/{record_id}",
+    description="Get detailed information of a specific record by ID",
+)
+def get_record(model_name: str, record_id: str) -> str:
+    """
+    Get a specific record by ID
+
+    Parameters:
+        model_name: Name of the Odoo model (e.g., 'res.partner')
+        record_id: ID of the record
+    """
+    odoo_client = get_odoo_client()
+    try:
+        record_id_int = int(record_id)
+        record = odoo_client.read_records(model_name, [record_id_int])
+        if not record:
+            return json.dumps(
+                {"error": f"Record not found: {model_name} ID {record_id}"}, indent=2
+            )
+        return json.dumps(record[0], indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+@mcp.resource(
+    "odoo://search/{model_name}/{domain}",
+    description="Search for records matching the domain",
+)
+def search_records_resource(model_name: str, domain: str) -> str:
+    """
+    Search for records that match a domain
+
+    Parameters:
+        model_name: Name of the Odoo model (e.g., 'res.partner')
+        domain: Search domain in JSON format (e.g., '[["name", "ilike", "test"]]')
+    """
+    odoo_client = get_odoo_client()
+    try:
+        # Parse domain from JSON string
+        domain_list = json.loads(domain)
+
+        # Set a reasonable default limit
+        limit = 10
+
+        # Perform search_read for efficiency
+        results = odoo_client.search_read(model_name, domain_list, limit=limit)
+
+        return json.dumps(results, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+# ----- Pydantic models for type safety -----
+
+
+class DomainCondition(BaseModel):
+    """A single condition in a search domain"""
+
+    field: str = Field(description="Field name to search")
+    operator: str = Field(
+        description="Operator (e.g., '=', '!=', '>', '<', 'in', 'not in', 'like', 'ilike')"
+    )
+    value: Any = Field(description="Value to compare against")
+
+    def to_tuple(self) -> List:
+        """Convert to Odoo domain condition tuple"""
+        return [self.field, self.operator, self.value]
+
+
+class SearchDomain(BaseModel):
+    """Search domain for Odoo models"""
+
+    conditions: List[DomainCondition] = Field(
+        default_factory=list,
+        description="List of conditions for searching. All conditions are combined with AND operator.",
+    )
+
+    def to_domain_list(self) -> List[List]:
+        """Convert to Odoo domain list format"""
+        return [condition.to_tuple() for condition in self.conditions]
+
+
+class EmployeeSearchResult(BaseModel):
+    """Represents a single employee search result."""
+
+    id: int = Field(description="Employee ID")
+    name: str = Field(description="Employee name")
+
+
+class SearchEmployeeResponse(BaseModel):
+    """Response model for the search_employee tool."""
+
+    success: bool = Field(description="Indicates if the search was successful")
+    result: Optional[List[EmployeeSearchResult]] = Field(
+        default=None, description="List of employee search results"
+    )
+    error: Optional[str] = Field(default=None, description="Error message, if any")
+
+
+class Holiday(BaseModel):
+    """Represents a single holiday."""
+
+    display_name: str = Field(description="Display name of the holiday")
+    start_datetime: str = Field(description="Start date and time of the holiday")
+    stop_datetime: str = Field(description="End date and time of the holiday")
+    employee_id: List[Union[int, str]] = Field(
+        description="Employee ID associated with the holiday"
+    )
+    name: str = Field(description="Name of the holiday")
+    state: str = Field(description="State of the holiday")
+
+
+class SearchHolidaysResponse(BaseModel):
+    """Response model for the search_holidays tool."""
+
+    success: bool = Field(description="Indicates if the search was successful")
+    result: Optional[List[Holiday]] = Field(
+        default=None, description="List of holidays found"
+    )
+    error: Optional[str] = Field(default=None, description="Error message, if any")
+
+
+# ----- MCP Tools -----
+
+
+@mcp.tool(description="Execute a custom method on an Odoo model")
+def execute_method(
+    ctx: Context,
+    model: str,
+    method: str,
+    args: List = None,
+    kwargs: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Execute a custom method on an Odoo model
+
+    Parameters:
+        model: The model name (e.g., 'res.partner')
+        method: Method name to execute
+        args: Positional arguments
+        kwargs: Keyword arguments
+
+    Returns:
+        Dictionary containing:
+        - success: Boolean indicating success
+        - result: Result of the method (if success)
+        - error: Error message (if failure)
+    """
+    odoo = ctx.request_context.lifespan_context.odoo
+    try:
+        args = args or []
+        kwargs = kwargs or {}
+
+        # Special handling for search methods like search, search_count, search_read
+        search_methods = ["search", "search_count", "search_read"]
+        if method in search_methods and args:
+            # Search methods usually have domain as the first parameter
+            # args: [[domain], limit, offset, ...] or [domain, limit, offset, ...]
+            normalized_args = list(
+                args
+            )  # Create a copy to avoid affecting the original args
+
+            if len(normalized_args) > 0:
+                # Process domain in args[0]
+                domain = normalized_args[0]
+                domain_list = []
+
+                # Check if domain is wrapped unnecessarily ([domain] instead of domain)
+                if (
+                    isinstance(domain, list)
+                    and len(domain) == 1
+                    and isinstance(domain[0], list)
+                ):
+                    # Case [[domain]] - unwrap to [domain]
+                    domain = domain[0]
+
+                # Normalize domain similar to search_records function
+                if domain is None:
+                    domain_list = []
+                elif isinstance(domain, dict):
+                    if "conditions" in domain:
+                        # Object format
+                        conditions = domain.get("conditions", [])
+                        domain_list = []
+                        for cond in conditions:
+                            if isinstance(cond, dict) and all(
+                                k in cond for k in ["field", "operator", "value"]
+                            ):
+                                domain_list.append(
+                                    [cond["field"], cond["operator"], cond["value"]]
+                                )
+                elif isinstance(domain, list):
+                    # List format
+                    if not domain:
+                        domain_list = []
+                    elif all(isinstance(item, list) for item in domain) or any(
+                        item in ["&", "|", "!"] for item in domain
+                    ):
+                        domain_list = domain
+                    elif len(domain) >= 3 and isinstance(domain[0], str):
+                        # Case [field, operator, value] (not [[field, operator, value]])
+                        domain_list = [domain]
+                elif isinstance(domain, str):
+                    # String format (JSON)
+                    try:
+                        parsed_domain = json.loads(domain)
+                        if (
+                            isinstance(parsed_domain, dict)
+                            and "conditions" in parsed_domain
+                        ):
+                            conditions = parsed_domain.get("conditions", [])
+                            domain_list = []
+                            for cond in conditions:
+                                if isinstance(cond, dict) and all(
+                                    k in cond for k in ["field", "operator", "value"]
+                                ):
+                                    domain_list.append(
+                                        [cond["field"], cond["operator"], cond["value"]]
+                                    )
+                        elif isinstance(parsed_domain, list):
+                            domain_list = parsed_domain
+                    except json.JSONDecodeError:
+                        try:
+                            import ast
+
+                            parsed_domain = ast.literal_eval(domain)
+                            if isinstance(parsed_domain, list):
+                                domain_list = parsed_domain
+                        except:
+                            domain_list = []
+
+                # Xác thực domain_list
+                if domain_list:
+                    valid_conditions = []
+                    for cond in domain_list:
+                        if isinstance(cond, str) and cond in ["&", "|", "!"]:
+                            valid_conditions.append(cond)
+                            continue
+
+                        if (
+                            isinstance(cond, list)
+                            and len(cond) == 3
+                            and isinstance(cond[0], str)
+                            and isinstance(cond[1], str)
+                        ):
+                            valid_conditions.append(cond)
+
+                    domain_list = valid_conditions
+
+                # Cập nhật args với domain đã chuẩn hóa
+                normalized_args[0] = domain_list
+                args = normalized_args
+
+                # Log for debugging
+                print(f"Executing {method} with normalized domain: {domain_list}")
+
+        result = odoo.execute_method(model, method, *args, **kwargs)
+        return {"success": True, "result": result}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(description="Search for employees by name")
+def search_employee(
+    ctx: Context,
+    name: str,
+    limit: int = 20,
+) -> SearchEmployeeResponse:
+    """
+    Search for employees by name using Odoo's name_search method.
+
+    Parameters:
+        name: The name (or part of the name) to search for.
+        limit: The maximum number of results to return (default 20).
+
+    Returns:
+        SearchEmployeeResponse containing results or error information.
+    """
+    odoo = ctx.request_context.lifespan_context.odoo
+    model = "hr.employee"
+    method = "name_search"
+
+    args = []
+    kwargs = {"name": name, "limit": limit}
+
+    try:
+        result = odoo.execute_method(model, method, *args, **kwargs)
+        parsed_result = [
+            EmployeeSearchResult(id=item[0], name=item[1]) for item in result
+        ]
+        return SearchEmployeeResponse(success=True, result=parsed_result)
+    except Exception as e:
+        return SearchEmployeeResponse(success=False, error=str(e))
+
+
+@mcp.tool(description="Search for holidays within a date range")
+def search_holidays(
+    ctx: Context,
+    start_date: str,
+    end_date: str,
+    employee_id: Optional[int] = None,
+) -> SearchHolidaysResponse:
+    """
+    Searches for holidays within a specified date range.
+
+    Parameters:
+        start_date: Start date in YYYY-MM-DD format.
+        end_date: End date in YYYY-MM-DD format.
+        employee_id: Optional employee ID to filter holidays.
+
+    Returns:
+        SearchHolidaysResponse:  Object containing the search results.
+    """
+    odoo = ctx.request_context.lifespan_context.odoo
+
+    # Validate date format using datetime
+    try:
+        datetime.strptime(start_date, "%Y-%m-%d")
+    except ValueError:
+        return SearchHolidaysResponse(
+            success=False, error="Invalid start_date format. Use YYYY-MM-DD."
+        )
+    try:
+        datetime.strptime(end_date, "%Y-%m-%d")
+    except ValueError:
+        return SearchHolidaysResponse(
+            success=False, error="Invalid end_date format. Use YYYY-MM-DD."
+        )
+
+    # Calculate adjusted start_date (subtract one day)
+    start_date_dt = datetime.strptime(start_date, "%Y-%m-%d")
+    adjusted_start_date_dt = start_date_dt - timedelta(days=1)
+    adjusted_start_date = adjusted_start_date_dt.strftime("%Y-%m-%d")
+
+    # Build the domain
+    domain = [
+        "&",
+        ["start_datetime", "<=", f"{end_date} 22:59:59"],
+        # Use adjusted date
+        ["stop_datetime", ">=", f"{adjusted_start_date} 23:00:00"],
+    ]
+    if employee_id:
+        domain.append(
+            ["employee_id", "=", employee_id],
+        )
+
+    try:
+        holidays = odoo.search_read(
+            model_name="hr.leave.report.calendar",
+            domain=domain,
+        )
+        parsed_holidays = [Holiday(**holiday) for holiday in holidays]
+        return SearchHolidaysResponse(success=True, result=parsed_holidays)
+
+    except Exception as e:
+        return SearchHolidaysResponse(success=False, error=str(e))