Odoo18 Mcp Project

[](https://mseep.ai/app/infovpcs-odoo18-mcp-project)

Odoo 18 MCP Integration (18.0 Branch)

Last Updated: 2025-06-06

[](https://www.python.org/downloads/) [](https://www.odoo.com/) [](https://github.com/modelcontextprotocol/python-sdk) []() [](LICENSE)

A robust integration server that connects MCP (Master Control Program) with Odoo 18.0 ERP system, focusing on efficient data synchronization, API management, and secure communications. This implementation provides a standardized interface for performing CRUD operations on Odoo 18 models through a simple API, with dynamic model discovery and field analysis capabilities.

Project Structure

odoo18_mcp_project/
├── src/                     # Main source code
│   ├── agents/             # AI agents implementation
│   ├── core/               # Core functionality
│   ├── mcp/               # MCP integration code
│   │   ├── server.py     # MCP server implementation
│   │   └── ...           # Other MCP-related modules
│   ├── odoo/              # Odoo integration code
│   │   ├── client.py      # Odoo client implementation
│   │   ├── schemas.py     # Data schemas and models
│   │   └── ...            # Other Odoo-related modules
│   ├── odoo_docs_rag/     # Odoo documentation retrieval
│   ├── odoo_tools/        # Odoo utility tools
│   ├── simple_odoo_code_agent/ # Simplified code agent
│   └── streamlit_client/  # Streamlit UI client
├── tests/                  # Test files
├── exports/                # Exported data files
├── generated_modules/      # Generated Odoo modules
├── logs/                   # Log files
├── odoo_docs/             # Odoo documentation
├── odoo_docs_index/       # Documentation index
└── tmp/                   # Temporary files

Features

• Odoo Integration
• XML-RPC connection to Odoo 18
• Model discovery using ir.model and ir.model.fields
• Dynamic field analysis and grouping
• NLP-based field importance analysis
• Relationship-aware search and operations

• CRUD Operations
• Create, Read, Update, Delete for any Odoo model
• Batch operations support
• Custom method execution
• Record templates generation

• Data Management
• Export/Import tools for CSV files
• Related records handling
• Relationship maintenance
• Batch processing support

• AI Integration
• DeepWiki integration for documentation
• Gemini LLM integration
• Natural language query parsing
• Code generation capabilities

• Development Tools
• Streamlit UI for module generation
• Documentation search
• CRUD testing interface
• Workflow visualization
• Mermaid diagram generation

Setup

1. Clone the repository:

git clone https://github.com/infovpcs/odoo18_mcp_project.git
cd odoo18_mcp_project

1. Create and activate virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

1. Install dependencies:

pip install -e .

1. Configure environment:

cp .env.example .env

Edit .env with your Odoo connection details:

ODOO_URL=http://localhost:8069
ODOO_DB=llmdb18
ODOO_USERNAME=admin
ODOO_PASSWORD=admin

# Optional AI/LLM integration
GEMINI_API_KEY=your_gemini_api_key_here
GEMINI_MODEL=gemini-2.0-flash

Usage

Running the Server

python mcp_server.py

Running Tests

python -m pytest tests/

Using Streamlit UI

streamlit run app.py

Tools

1. Basic CRUD Operations

• search_records: Search for records in any Odoo model
• create_record: Create new records
• update_record: Update existing records
• delete_record: Delete records
• get_record_template: Get a template for creating records

1. Advanced Search and Documentation

• advanced_search: Perform advanced natural language search
• retrieve_odoo_documentation: Retrieve information from Odoo 18 documentation
• get_field_groups: Get field groups for a model
• analyze_field_importance: Analyze field importance using NLP

1. Export/Import Tools

• export_records_to_csv: Export records to CSV
• import_records_from_csv: Import records from CSV
• export_related_records_to_csv: Export parent-child related records
• import_related_records_from_csv: Import parent-child related records

1. Code Generation Tools

• generate_module: Generate Odoo 18 module code using Simple Odoo Code Agent
• generate_npx: Generate diagrams from Mermaid markdown

Documentation

For more detailed documentation, see:

• [PLANNING.md](PLANNING.md) - Project planning and architecture
• [TASK.md](TASK.md) - Current tasks and progress
• [MCPOVERVIEW.md](MCPOVERVIEW.md) - MCP integration details
• [MCPSDKREADME.md](MCPSDKREADME.md) - MCP SDK documentation
• [CLIENTREADME.md](CLIENTREADME.md) - Client usage documentation

License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

Installation

Prerequisites

• Python 3.10 or higher
• Odoo 18.0 instance
• Access to Odoo database
• Claude Desktop (optional, for AI integration)
• Compatible PyTorch version (2.2.x recommended for macOS)
• NumPy Note: The BRAVE_API_KEY is required for the online search functionality in the enhanced RAG tool. You can obtain a Brave Search API key from the Brave Search Developer Portal.

Claude Desktop Integration

The project includes comprehensive integration with Claude Desktop, allowing you to use all the Odoo 18 MCP tools directly within the Claude AI assistant interface.

Installation Options

Option 1: Using the MCP CLI (Recommended)

1. Install the MCP SDK with CLI support:

pip install "mcp[cli]"

1. Install the MCP server in Claude Desktop:

# Make sure to set these environment variables in your shell or .env file first:
# export ODOO_URL=http://localhost:8069

# export ODOO_PASSWORD=admin
# export GEMINI_API_KEY=your_key
# export BRAVE_API_KEY=your_key

mcp install mcp_server.py --name "Odoo 18 Integration" \
  --command "$(which python3)" \
  --args "$(pwd)/mcp_server.py" \
  --env ODOO_URL=${ODOO_URL} \
  --env ODOO_DB=${ODOO_DB} \
  --env ODOO_USERNAME=${ODOO_USERNAME} \
  --env ODOO_PASSWORD=${ODOO_PASSWORD} \
  --env GEMINI_API_KEY=${GEMINI_API_KEY} \
  --env GEMINI_MODEL=gemini-2.0-flash \
  --env BRAVE_API_KEY=${BRAVE_API_KEY} \
  --env ODOO_DOCS_DIR="$(pwd)/odoo_docs" \
  --env ODOO_INDEX_DIR="$(pwd)/odoo_docs_index" \
  --env ODOO_DB_PATH="$(pwd)/odoo_docs_index/embeddings.db" \

This command will:

• Register the MCP server with Claude Desktop
• Configure the necessary environment variables
• Set up the server with the correct name and description

Option 2: Using the Automated Script

We provide a convenient script that automatically updates the Claude Desktop configuration:

# Make the script executable
chmod +x update_claude_config.sh

# Run the script
./update_claude_config.sh

This script will:

• Detect your Claude Desktop configuration location based on your OS
• Load environment variables from your .env file (including GEMINIAPIKEY)
• Update the Claude Desktop configuration with the correct values
• Handle environment variable substitution automatically
• Create a backup of your existing configuration
• Validate the updated configuration

Option 3: Manual Configuration

You can also manually update the Claude Desktop configuration file:

1. Locate your Claude Desktop configuration file:

• macOS: ~/Library/Application Support/Claude/config.json
• Windows: %APPDATA%\Claude\config.json
• Linux: ~/.config/Claude/config.json

1. Open the claude_config.json file in a text editor and add the following to the servers section:

{
    "odoo18-mcp": {
        "name": "Odoo 18 Integration",
        "description": "Dynamic Odoo 18 integration with MCP",
        "command": "/full/path/to/your/python",
        "args": ["/full/path/to/your/odoo18_mcp_project/mcp_server.py"],
        "env": {
            "ODOO_URL": "http://localhost:8069",
            "ODOO_DB": "llmdb18",
            "ODOO_USERNAME": "admin",
            "ODOO_PASSWORD": "admin",
            "GEMINI_API_KEY": "your_gemini_api_key_here",
            "GEMINI_MODEL": "gemini-2.0-flash",
            "BRAVE_API_KEY": "your_brave_api_key_here",
            "ODOO_DOCS_DIR": "/full/path/to/your/odoo18_mcp_project/odoo_docs",
            "ODOO_INDEX_DIR": "/full/path/to/your/odoo18_mcp_project/odoo_docs_index",
            "ODOO_DB_PATH" : "/full/path/to/your/odoo18_mcp_project/odoo_docs_index/embeddings.db"
        }
    }
}

Important Configuration Notes:

• Replace /full/path/to/your/python with the actual full path to your Python executable. You can find this by running which python3 in your terminal. For example, if you're using a virtual environment, it might be something like /Users/username/workspace/odoo18_mcp_project/.venv/bin/python3.
• Replace your_gemini_api_key_here with your actual Google Gemini API key if you want to use the Odoo Module Generator with Gemini integration.
• Replace your_brave_api_key_here with your actual Brave Search API key if you want to use the online search functionality in the enhanced RAG tool. You can obtain a Brave Search API key from the Brave Search Developer Portal.
• Make sure the path to mcp_server.py is correct for your installation.

Verifying the Installation

After configuring Claude Desktop:

1. Restart Claude Desktop to apply the changes
2. Open Claude Desktop and click on the server selection dropdown (top-right corner)
3. Select "Odoo 18 Integration" from the list
4. Check the Claude Desktop logs for successful connection to Odoo
5. Try a simple command like /tool search_records model_name=res.partner query=company to verify functionality

Troubleshooting Claude Desktop Integration

If you encounter issues with the Claude Desktop integration:

1. Check the Claude Desktop logs:

• macOS: ~/Library/Logs/Claude/main.log
• Windows: %APPDATA%\Claude\logs\main.log
• Linux: ~/.config/Claude/logs/main.log

1. Verify Python path:

• Make sure the Python path in the configuration is correct and accessible
• The Python executable should have the MCP SDK installed

1. Check environment variables:

• Verify that all environment variables are correctly set
• Make sure the Odoo server is running and accessible at the specified URL

1. Restart Claude Desktop:

• Sometimes a simple restart resolves connection issues

1. Run the MCP server directly:

• Try running python mcp_server.py directly to check for any errors

1. Use the standalone server for testing:

• Run python standalone_mcp_server.py and test the tools using curl commands

Using Claude Desktop with Odoo 18 Integration

Once configured, you can use all the Odoo 18 MCP tools directly within Claude Desktop:

1. Tool Commands: Use /tool commands to execute specific operations

`` /tool search_records model_name=res.partner query="company" /tool get_record_template model_name=product.product /tool run_odoo_code_agent query="Create a customer feedback module" use_gemini=true ``

1. Resource Commands: Use /resource commands to access Odoo resources

`` /resource odoo://models/all /resource odoo://model/res.partner/metadata /resource odoo://model/product.product/records ``

1. Prompt Commands: Use /prompt commands for guided assistance

`` /prompt create_record_prompt model_name=res.partner /prompt export_records_prompt model_name=res.partner /prompt odoo_code_agent_prompt ``

The integration provides a seamless experience, allowing you to work with Odoo directly from Claude Desktop without switching between applications.

Building from Source

If you want to build the package for distribution:

python -m pip install build
python -m build

This will create distribution packages in the dist/ directory.

Docker Support

The project includes comprehensive Docker support for development, testing, and production deployment.

Quick Start with Make

We provide a Makefile for common Docker operations:

# Set up required directories (logs, exports, tmp, data, generated_modules)
make setup

# Build Docker images
make build

# Start development environment
make dev

# Run tests
make test

# Run specific test categories
make test-mcp         # Run MCP server tests
make test-agent       # Run Odoo code agent tests
make test-utils       # Run Odoo code agent utilities tests
make test-export-import  # Run export/import agent tests

# Start production environment
make prod

# View logs
make logs

# Stop all services
make down

# Clean up everything
make clean

Docker Compose Configuration

The project includes multiple Docker Compose files for different environments:

• docker-compose.yml: Base configuration for all environments
• docker-compose.override.yml: Development-specific overrides (automatically used with docker-compose up)
• docker-compose.prod.yml: Production-specific configuration

Development Environment

For local development:

# Start all services in development mode
docker-compose up -d

# Or using the Makefile
make dev

This will:

• Mount your local code into the container for live development
• Enable debug mode and detailed logging
• Create required directories for logs, exports, and temporary files
• Set up appropriate environment variables

Production Deployment

For production deployment:

# Start production environment
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# Or using the Makefile
make prod

Production mode includes:

• Multi-stage build for smaller image size
• Non-root user for better security
• Resource limits to prevent container resource exhaustion
• Health checks for better reliability
• Restart policies for automatic recovery
• Log rotation to prevent disk space issues
• Network isolation for better security

Container Architecture

The Docker setup includes three main services:

1. mcp-server: The main MCP server for integration with Claude Desktop

• Exposes port 8000 for API access
• Connects to Odoo via XML-RPC
• Provides MCP tools for Claude Desktop

1. standalone-server: A standalone server for testing MCP tools

• Exposes port 8001 for API access
• Provides HTTP endpoints for testing MCP tools
• Useful for development and testing without Claude Desktop

1. test-runner: A service for running automated tests

• Runs function tests and tool tests
• Validates the MCP server functionality
• Useful for CI/CD pipelines

Environment Variables

You can customize the Docker environment by setting environment variables:

# In .env file or command line
ODOO_URL=http://your-odoo-server:8069
ODOO_DB=your_database
ODOO_USERNAME=your_username
ODOO_PASSWORD=your_password
GEMINI_API_KEY=your_gemini_api_key_here
GEMINI_MODEL=gemini-2.0-flash
BRAVE_API_KEY=your_brave_api_key_here
ODOO_DOCS_DIR="/Users/vinusoft85/workspace/odoo18_mcp_project/odoo_docs",
ODOO_INDEX_DIR="/Users/vinusoft85/workspace/odoo18_mcp_project/odoo_docs_index",
ODOO_DB_PATH="/Users/vinusoft85/workspace/odoo18_mcp_project/odoo_docs_index/embeddings.db"
MCP_DEBUG=true
MCP_LOG_LEVEL=DEBUG

Volume Management

The Docker setup includes several volumes for persistent data:

• mcp_data: Persistent data storage
• mcp_logs: Persistent logs storage
• ./exports: Directory for exported files
• ./tmp: Directory for temporary files
• ./generated_modules: Directory for Odoo module files generated by the Odoo Module Generator

Health Checks

All services include health checks to ensure they're running properly:

# Check the heal

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [infovpcs](https://github.com/infovpcs)
- **Source:** [infovpcs/odoo18_mcp_project](https://github.com/infovpcs/odoo18_mcp_project)
- **License:** MIT

Install and usage instructions live in the source repository linked above.