Mentioned in the README for supporting the project creator, but no actual integration functionality is provided.
Supports configuration for use with GitHub Copilot in VS Code, allowing the Copilot AI to interact with Odoo systems.
Enables interaction with Odoo ERP systems, providing tools to search, create, update, and delete records across various business modules such as customers, products, invoices, and sales orders. Supports field validation, pagination, and respects Odoo's permission model.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Server for Odoofind the latest 5 sales orders for customer 'Acme Corp'"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Server for Odoo
An MCP server that enables AI assistants like Claude to interact with Odoo ERP systems. Access business data, search records, create new entries, update existing data, and manage your Odoo instance through natural language.
Works with any Odoo instance! Use YOLO mode for quick testing and demos with any standard Odoo installation. For enterprise security, access controls, and production use, install the Odoo MCP module.
Features
🔍 Search and retrieve any Odoo record (customers, products, invoices, etc.)
✨ Create new records with field validation and permission checks
✏️ Update existing data with smart field handling
🗑️ Delete records respecting model-level permissions
🔢 Count records matching specific criteria
📋 Inspect model fields to understand data structure
🔐 Secure access with API key or username/password authentication
🎯 Smart pagination for large datasets
🧠 Smart field selection — automatically picks the most relevant fields per model
💬 LLM-optimized output with hierarchical text formatting
🌍 Multi-language support — get responses in your preferred language
🚀 YOLO Mode for quick access with any Odoo instance (no module required)
Related MCP server: Odoo MCP Server
Installation
Prerequisites
Python 3.10 or higher
Access to an Odoo instance:
Standard mode (production): Version 16.0+ with the Odoo MCP module installed
YOLO mode (testing/demos): Any Odoo version with XML-RPC enabled (no module required)
Install UV First
The MCP server runs on your local computer (where Claude Desktop is installed), not on your Odoo server. You need to install UV on your local machine:
After installation, restart your terminal to ensure UV is in your PATH.
Installing via MCP Settings (Recommended)
Add this configuration to your MCP settings:
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
Add to .mcp.json in your project root:
Or use the CLI:
Add to ~/.cursor/mcp.json:
Add to .vscode/mcp.json in your workspace:
Note: VS Code uses
"servers"as the root key, not"mcpServers".
Add to ~/.codeium/windsurf/mcp_config.json:
Add to ~/.config/zed/settings.json:
Alternative Installation Methods
Then use mcp-server-odoo as the command in your MCP configuration.
Then use the full path to the package in your MCP configuration.
Configuration
Environment Variables
The server requires the following environment variables:
Variable | Required | Description | Example |
| Yes | Your Odoo instance URL |
|
| Yes* | API key for authentication |
|
| Yes* | Username (if not using API key) |
|
| Yes* | Password (if not using API key) |
|
| No | Database name (auto-detected if not set) |
|
| No | Language/locale for Odoo responses |
|
| No | YOLO mode - bypasses MCP security (⚠️ DEV ONLY) |
|
*Either ODOO_API_KEY or both ODOO_USER and ODOO_PASSWORD are required.
Notes:
If database listing is restricted on your server, you must specify
ODOO_DBAPI key authentication is recommended for better security
The server also loads environment variables from a
.envfile in the working directory
Advanced Configuration
Variable | Default | Description |
|
| Default number of records returned per search |
|
| Maximum allowed record limit per request |
|
| Maximum fields returned by smart field selection |
|
| Log level ( |
|
| Enable structured JSON log output |
| — | Path for rotating log file (10 MB, 5 backups) |
|
| Transport type ( |
|
| Host to bind for HTTP transport |
|
| Port to bind for HTTP transport |
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.
2. streamable-http
Standard HTTP transport for REST API-style access and remote connectivity.
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.
Setting up Odoo
Install the MCP module:
Download the mcp_server module
Install it in your Odoo instance
Navigate to Settings > MCP Server
Enable models for MCP access:
Go to Settings > MCP Server > Enabled Models
Add models you want to access (e.g., res.partner, product.product)
Configure permissions (read, write, create, delete) per model
Generate an API key:
Go to Settings > Users & Companies > Users
Select your user
Under the "API Keys" tab, create a new key
Copy the key for your MCP configuration
YOLO Mode (Development/Testing Only) ⚠️
YOLO mode allows the MCP server to connect directly to any standard Odoo instance without requiring the MCP module. This mode bypasses all MCP security controls and is intended ONLY for development, testing, and demos.
🚨 WARNING: Never use YOLO mode in production environments!
YOLO Mode Levels
Read-Only Mode (
ODOO_YOLO=read):Allows all read operations (search, read, count)
Blocks all write operations (create, update, delete)
Safe for demos and testing
Shows "READ-ONLY" indicators in responses
Full Access Mode (
ODOO_YOLO=true):Allows ALL operations without restrictions
Full CRUD access to all models
EXTREMELY DANGEROUS - use only in isolated environments
Shows "FULL ACCESS" warnings in responses
YOLO Mode Configuration
When to Use YOLO Mode
✅ Appropriate Uses:
Local development with test data
Quick demos with non-sensitive data
Testing MCP clients before installing the MCP module
Prototyping in isolated environments
❌ Never Use For:
Production environments
Instances with real customer data
Shared development servers
Any environment with sensitive information
YOLO Mode Security Notes
Connects directly to Odoo's standard XML-RPC endpoints
Bypasses all MCP access controls and model restrictions
No rate limiting is applied
All operations are logged but not restricted
Model listing shows 200+ models instead of just enabled ones
Usage Examples
Once configured, you can ask Claude:
Search & Retrieve:
"Show me all customers from Spain"
"Find products with stock below 10 units"
"List today's sales orders over $1000"
"Search for unpaid invoices from last month"
"Count how many active employees we have"
"Show me the contact information for Microsoft"
Create & Manage:
"Create a new customer contact for Acme Corporation"
"Add a new product called 'Premium Widget' with price $99.99"
"Create a calendar event for tomorrow at 2 PM"
"Update the phone number for customer John Doe to +1-555-0123"
"Change the status of order SO/2024/001 to confirmed"
"Delete the test contact we created earlier"
Available Tools
search_records
Search for records in any Odoo model with filters.
Field Selection Options:
Omit
fieldsor set tonull: Returns smart selection of common fieldsSpecify field list: Returns only those specific fields
Use
["__all__"]: Returns all fields (use with caution)
get_record
Retrieve a specific record by ID.
Field Selection Options:
Omit
fieldsor set tonull: Returns smart selection of common fields with metadataSpecify field list: Returns only those specific fields
Use
["__all__"]: Returns all fields without metadata
list_models
List all models enabled for MCP access.
list_resource_templates
List available resource URI templates and their patterns.
create_record
Create a new record in Odoo.
update_record
Update an existing record.
delete_record
Delete a record from Odoo.
Smart Field Selection
When you omit the fields parameter (or set it to null), the server automatically selects the most relevant fields for each model using a scoring algorithm:
Essential fields like
id,name,display_name, andactiveare always includedBusiness-relevant fields (state, amount, email, phone, partner, etc.) are prioritized
Technical fields (message threads, activity tracking, website metadata) are excluded
Expensive fields (binary, HTML, large text, computed non-stored) are skipped
The default limit is 15 fields per request. Responses include metadata showing which fields were returned and how many total fields are available. You can adjust the limit with ODOO_MCP_MAX_SMART_FIELDS or bypass it entirely with fields: ["__all__"].
Resources
The server also provides direct access to Odoo data through resource URIs:
URI Pattern | Description |
| Retrieve a specific record by ID |
| Search records with default settings (first 10 records) |
| Count all records in a model |
| Get field definitions and metadata for a model |
Examples:
odoo://res.partner/record/1— Get partner with ID 1odoo://product.product/search— List first 10 productsodoo://res.partner/count— Count all partnersodoo://product.product/fields— Show all fields for products
Note: Resource URIs don't support query parameters (like
?domain=...). For filtering, pagination, and field selection, use thesearch_recordstool instead.
How It Works
The server translates MCP tool calls into Odoo XML-RPC requests. It handles authentication, access control, field selection, data formatting, and error handling — presenting Odoo data in an LLM-friendly hierarchical text format.
Security
Always use HTTPS in production environments
Keep your API keys secure and rotate them regularly
Configure model access carefully - only enable necessary models
The MCP module respects Odoo's built-in access rights and record rules
Each API key is linked to a specific user with their permissions
Troubleshooting
If you're getting connection errors:
Verify your Odoo URL is correct and accessible
Check that the MCP module is installed: visit
https://your-odoo.com/mcp/healthEnsure your firewall allows connections to Odoo
If authentication fails:
Verify your API key is active in Odoo
Check that the user has appropriate permissions
Try regenerating the API key
For username/password auth, ensure 2FA is not enabled
If you can't access certain models:
Go to Settings > MCP Server > Enabled Models in Odoo
Ensure the model is in the list and has appropriate permissions
Check that your user has access to that model in Odoo's security settings
This error means UV is not installed or not in your PATH:
Solution 1: Install UV (see Installation section above)
Solution 2: macOS PATH Issue Claude Desktop on macOS doesn't inherit your shell's PATH. Try:
Quit Claude Desktop completely (Cmd+Q)
Open Terminal
Launch Claude from Terminal:
open -a "Claude"
Solution 3: Use Full Path Find UV location and use full path:
Then update your config:
If you see "Access Denied" when listing databases:
This is normal - some Odoo instances restrict database listing for security
Make sure to specify
ODOO_DBin your configurationThe server will use your specified database without validation
Example configuration:
Note: ODOO_DB is required if database listing is restricted on your server.
This error occurs when Python cannot verify SSL certificates, often on macOS or corporate networks.
Solution: Add SSL certificate path to your environment configuration:
This tells Python where to find the system's SSL certificate bundle for HTTPS connections. The path /etc/ssl/cert.pem is the standard location on most systems.
Enable debug logging for more information:
Development
Testing
Transport Tests
You can test both stdio and streamable-http transports to ensure they're working correctly:
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:
License
This project is licensed under the Mozilla Public License 2.0 (MPL-2.0) - see the LICENSE file for details.
Contributing
Contributions are very welcome! Please see the CONTRIBUTING guide for details.
Support
Thank you for using this project! If you find it helpful and would like to support my work, kindly consider buying me a coffee. Your support is greatly appreciated!
And do not forget to give the project a star if you like it! :star: