Panda Odoo

You can run and interact with the Panda Odoo MCP Server to access Odoo data through the MCP (Model Context Protocol). It supports real-time streaming and standard requests, handles Odoo records and binary fields, and provides tooling to read, create, update, delete, and call custom methods while managing authentication, sessions, and rate limits.

How to use

You connect an MCP client to the server using either a local stdio setup or an HTTP-based mode for streaming or classic requests. In stdio, you launch the MCP server as a local process and communicate directly through standard input and output. In HTTP modes, you send requests over HTTP to the server endpoint and optionally receive streaming updates in real time. From your client, you perform operations such as reading records, creating or updating data, deleting records, and invoking custom server-side methods. Use the appropriate connection type for your workflow and ensure your Odoo instance is reachable with the configured credentials.

Key capabilities you can leverage include querying Odoo records, fetching binary fields, listening for real-time updates, and performing write operations against the Odoo database. For secure access, ensure authentication is configured, sessions are managed properly, and that rate limits are respected to maintain reliable performance.

How to install

Prerequisites you need before installing are Python 3.9 or newer and Docker if you want to run in containers. You should also have a working Odoo 15.0+ instance with the base, web, and bus modules.

Step by step commands to install and run the server in a direct, non-container setup:

# Clone the repository
git clone https://github.com/pandeussilvae/mcp-odoo-panda.git
cd mcp-odoo-panda

# Install dependencies
pip install .

# To install with caching support
pip install .[caching]

# To install with development tools
pip install .[dev]

# Copy the example configuration file
cp odoo_mcp/config/config.example.json odoo_mcp/config/config.json

# Edit config.json with your settings
# nano odoo_mcp/config/config.json

If you prefer running via Docker, start the server using Docker Compose:

# Clone the repository
git clone https://github.com/pandeussilvae/mcp-odoo-panda.git
cd mcp-odoo-panda

# Start with Docker Compose
docker-compose up -d

Configuration and startup options

Configure the server through a JSON file. You can begin with the example and tailor it to your environment.

The server can run in multiple connection modes. Choose by setting the connection_type in your config.json. Supported values are stdio, streamable_http, and http.

{
  "mcpServers": {
    "mcp-odoo-panda": {
      "command": "/usr/bin/python3",
      "args": [
        "--directory",
        "/path/to/mcp-odoo-panda",
        "mcp/server.py",
        "--config",
        "/path/to/mcp-odoo-panda/odoo_mcp/config/config.json"
      ]
    }
  },
  "odoo_url": "http://localhost:8069",
  "database": "my_database",
  "username": "admin",
  "api_key": "admin",
  "protocol": "xmlrpc",
  "connection_type": "streamable_http",
  "requests_per_minute": 120,
  "rate_limit_max_wait_seconds": 5,
  "pool_size": 5,
  "timeout": 30,
  "session_timeout_minutes": 60,
  "http": {
    "host": "0.0.0.0",
    "port": 8080,
    "streamable": true
  },
  "logging": {
    "level": "INFO",
    "format": "% (asctime)s - % (name)s - % (levelname)s - % (message)s",
    "handlers": [
      {"type": "StreamHandler", "level": "INFO"},
      {"type": "FileHandler", "filename": "server.log", "level": "DEBUG"}
    ]
  }
}

You can also configure the server via environment variables. If you use a container or .env file, values take precedence over the config.json file.

Networking and endpoints

• For streamable HTTP mode, the endpoint is POST /mcp with streaming enabled. Headers should include Content-Type: application/json and Connection: keep-alive.
• For classic HTTP mode, the endpoint is POST /mcp with a single request/response interaction. Include Content-Type: application/json.
• If you enable Server-Sent Events, you can open GET /sse to receive server-pushed events.

Starting the server

To start in stdio mode (default): use Python to run the MCP server directly. If you provide a specific config, include its path.

# Start the server in stdio mode without specifying the configuration file
python -m odoo_mcp.server

# Start the server in stdio mode with a specific configuration file
python -m odoo_mcp.server /path/to/config.json

To start in streamable_http mode you pass the mode as an argument or via config. If you have a config.json, you can specify it when starting.

# Start the server in streamable_http mode without specifying the configuration file
python -m odoo_mcp.server streamable_http

# Start the server in streamable_http mode with a specific configuration file
python -m odoo_mcp.server streamable_http /path/to/config.json

Security and maintenance

• Use an SSL certificate for production deployments to secure HTTPS traffic.
• Ensure a properly configured firewall and consider VPN access for additional protection.
• Manage authentication and session handling carefully to avoid unauthorized access.
• Apply rate limiting to prevent abuse and keep the system responsive.

Troubleshooting

Common issues usually relate to connectivity, authentication, protocol compatibility, or rate limiting. Verify that Odoo is reachable at the configured URL and port, that the database exists and is accessible, and that authentication credentials are correct. Check the logs for precise error messages and ensure the chosen connection_type matches your client capabilities.

Running with Docker

You can run the MCP Server inside a Docker container. Build the image, then start the containers and access the MCP endpoint on port 8080 by default.

docker-compose up -d

Available tools

initialize

Initialize the MCP client session and establish a connection to the Odoo MCP server.

get_resource

Retrieve a specific Odoo resource or record, such as a partner or product, via the MCP interface.

read_resource

Read data from an Odoo resource, supporting single records and lists of records.

create_resource

Create a new Odoo record through the MCP server.

update_resource

Update fields on an existing Odoo record via the MCP interface.

delete_resource

Delete an Odoo record using the MCP server.

call_method

Call a custom method on an Odoo model through MCP.