Skip to main content
Glama
Odoo Developer Assistant MCP

Odoo Developer Assistant MCP

by pks0204

Odoo Developer Assistant MCP

CI

An MCP (Model Context Protocol) server that helps Odoo developers investigate common errors, inspect custom addons, and validate module manifests.

The project provides initial troubleshooting suggestions and static validation. It does not modify an Odoo database or claim that a suggested diagnosis is confirmed.

Features

1. Odoo Error Analyzer

The analyze_odoo_error tool analyzes Odoo runtime error tracebacks, PostgreSQL constraint violations, and Owl 2 browser crashes, delivering structured root-cause diagnoses and actionable code fixes.

Capabilities include:

  • Full Traceback Stack Parsing: Extracts the exact failing custom file, line number, method name, and code snippet, filtering out internal framework frames (odoo/http.py, odoo/models.py).

  • PostgreSQL Database Constraint Violations: Specifically diagnoses NOT NULL constraint violations (identifying exact column and table), duplicate key UNIQUE violations (extracting conflicting constraint, key, and duplicate value), and foreign key constraint failures.

  • Modern Owl 2 & Web Client Errors: Pinpoints unregistered Owl components, missing QWeb templates (<t t-name="...">), and component lifecycle scope errors (accessing this.env outside setup()).

  • Asset Bundle Diagnostics: Identifies broken SCSS variables, asset compiler errors, and missing bundle assets.

  • Concrete Fix Recommendations: Delivers actionable fix suggestions tailored to the exact failure point.

2. Odoo Module Inspector

The inspect_odoo_module tool reads an addon's __manifest__.py file and reports:

  • Module name and version

  • Dependencies

  • Data file references

  • Installation settings

  • Dependency availability across supplied addon directories

Dependency checks cover only the directories supplied to the tool. A dependency reported as missing may still exist elsewhere in an Odoo installation.

3. Odoo Manifest & Pre-Flight Installation Validator

The validate_odoo_manifest tool performs deep static validation and installation pre-flight checks:

  • Required Fields & Types: Validates required metadata fields (name, version, depends) and field types.

  • Referenced File Integrity: Verifies that all files declared in data and demo exist on disk, with confinement checks against path traversal or symlink escapes.

  • External Dependencies Verification: Inspects external_dependencies to verify that declared Python packages (external_dependencies['python']) are importable (with automatic distribution-to-module mapping) and required system executables (external_dependencies['bin']) exist on PATH, generating exact pip install <pkg> recommendations.

  • Sequential Data Load Order: Detects unsafe load ordering in 'data' (e.g., view files declared before security/ir.model.access.csv or sequence files) to prevent install-time ParseError: External ID not found crashes.

  • Dependency Guard: Flags self-dependencies (addon depending on itself) and circular dependency chains across local addon directories.

  • Syntax Safety: Parses the manifest AST safely without executing arbitrary Python code.

4. Odoo XML View Analyzer

The analyze_odoo_xml_view tool performs static analysis on Odoo XML data and view files to detect structural errors, syntax mistakes, and suspicious references before loading them into an Odoo database.

Capabilities include:

  • XML Syntax Validation: Identifies malformed XML with exact line and column numbers.

  • Root Element Checks: Verifies expected <odoo> or legacy <openerp> root tags.

  • Record Identifier Checks: Checks for required id and model attributes on <record> tags, flags whitespace in IDs, and detects duplicate record IDs across the file.

  • View Architecture Inspection: Verifies that ir.ui.view records define non-empty <field name="arch" type="xml"> blocks.

  • External ID Reference Extraction: Extracts ref attributes and ref('...') expressions as informational items requiring verification in manifest dependencies or database models.

  • File Safety: Enforces a 500 KB maximum file size limit, handles encoding issues, rejects directories, and supports optional addon_path confinement to prevent path traversal or symlink escapes.

5. Odoo Python Model Analyzer

The analyze_odoo_python_model tool statically analyzes Python model files using Python's standard ast module to detect structural errors, missing attributes, decorator misconfigurations, and common mistakes without executing untrusted code.

Capabilities include:

  • Model Class Inspection: Detects classes inheriting from models.Model, models.TransientModel, or models.AbstractModel.

  • Model Attribute Validation: Checks for _name, _inherit, and flags new models missing a _description attribute.

  • Relational Field Checks: Flags fields.Many2one or fields.Many2many missing comodel names, and fields.One2many missing inverse field names.

  • On-delete Validation: Warns about suspicious ondelete configurations on Many2one fields.

  • Decorator Diagnostics: Flags @api.depends(), @api.onchange(), or @api.constrains() decorators with empty arguments.

  • File Safety: Enforces a 500 KB maximum file size limit, handles encoding gracefully, and supports optional addon_path sandboxing.

6. Odoo Security Analyzer

The analyze_odoo_security tool inspects Odoo security files (ir.model.access.csv and security XML records) to detect syntax mistakes, missing model prefixes, invalid permission flags, and malformed rules before module loading.

Capabilities include:

  • Exact CSV Header Verification: Verifies the strict 8-column header (id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink).

  • Model ID Prefix Validation: Checks that model_id:id has the mandatory model_ prefix (e.g. model_custom_order, not custom.order).

  • Binary Permission Flags: Validates that all permission columns (perm_read, perm_write, perm_create, perm_unlink) are strictly 0 or 1.

  • Integrity Checks: Detects duplicate access rule IDs and column count mismatches.

  • Global Rule Detection: Identifies rules with empty group_id:id that grant global permissions across all users.

  • Security XML Analysis: Validates ir.rule record definitions to ensure model_id and domain_force are declared.

7. Unified Odoo Addon Health Check

The check_odoo_addon_health tool acts as a single, comprehensive audit command for an entire Odoo addon directory. It orchestrates manifest, view, model, and security analyzers into a consolidated diagnostic report.

Capabilities include:

  • Manifest & Dependency Audit: Verifies manifest integrity and checks cross-directory dependency resolution.

  • Views & Data Audit: Discovers and audits all declared and directory XML view/data files.

  • Python Models Audit: Automatically discovers and inspects all model files in models/.

  • Security Audit: Audits security/ir.model.access.csv and security XML rules.

  • Cross-File Consistency Audit: Cross-references models, views, and security files within the addon to detect custom models missing security access rules and XML view <field> tags referencing undeclared model fields.

  • Consolidated Health Scoring: Assigns an overall status (HEALTHY, NEEDS_ATTENTION, CRITICAL_ISSUES) with file counts, error/warning summaries, cross-file issues, and prioritized action suggestions.

8. Live Odoo Metadata Verifier

The verify_odoo_live_metadata tool enables developers to connect to an active Odoo instance (local development Docker, test instance, or staging server) via read-only XML-RPC to dynamically verify models, fields, and external XML IDs before deployment.

Capabilities include:

  • Whole-Addon Batch Verification: Supply an addon_path to automatically extract and verify all referenced models, relational comodels, view fields, and external XML IDs across the addon in a single operation.

  • Enterprise Schema Batch Chunking: Automatically chunks large query sets (40 XML IDs per domain batch, 80 models/fields per query) to prevent PostgreSQL and Odoo RPC recursion limit crashes on massive enterprise schemas with 1,000+ records.

  • Model Verification: Queries ir.model to check whether referenced models exist in the target database.

  • Field Verification: Queries ir.model.fields to verify that field names, types (ttype), and attributes exist on the target model.

  • External XML ID Verification: Queries ir.model.data to verify external IDs (e.g. base.group_user, sale.action_orders).

  • Unified Health Check & CLI Integration: Integrates directly with check_odoo_addon_health(live_connection=...) and CLI runner --live-url, --live-db, --live-user, --live-password.

  • Read-Only Safety: Strictly executes read-only search_read calls; never writes to or modifies the database.

  • Credential Protection: Passwords and API keys are never leaked or stored in responses.

  • Zero Dependencies: Powered exclusively by Python's standard library xmlrpc.client.

9. Odoo Migration & OpenUpgrade Scaffolder

The migrate_odoo_addon tool automates the code migration of custom addons from Odoo 16, 17, and 18 to Odoo 19 (Community and Enterprise) and scaffolds OCA OpenUpgrade database migration templates.

Capabilities include:

  • XML View Modernization: Automatically converts deprecated <tree> tags to <list> (mandatory in Odoo 18/19), refactors legacy attrs="{...}" dictionaries into direct Python expressions (invisible="...", readonly="...", required="..."), and transforms states="..." attributes into boolean domain expressions.

  • Python AST Modernization & Diagnostics: Statically inspects Python model files to detect breaking API changes:

    • Detects legacy name_get() methods (removed in Odoo 17+) and provides drop-in _compute_display_name() implementations.

    • Flags model create() overrides missing @api.model_create_multi and provides batch-compatible vals_list signatures.

    • Flags deprecated ORM calls (e.g. fields.Date.to_string, fields.Datetime.from_string, obsolete _name_search signatures).

    • Flags manual transaction calls (cr.commit()) that break test suites and rollback safety.

    • Flags obsolete legacy decorators (@api.multi, @api.one, @api.returns).

  • Enterprise vs Community Edition Audit: Inspects module dependencies against known Odoo Enterprise apps (e.g. web_studio, account_reports, helpdesk, sign) and warns if an Enterprise license is required for Odoo 19 or if the module can run on Community.

  • Manifest Version Bumping: Updates version declarations in __manifest__.py to target version 19.0.x.x while preserving custom sub-versioning formats.

  • OpenUpgrade Database Scaffolding: Automatically scaffolds OCA standard migrations/19.0.1.0/ structure including:

    • pre-migration.py: Standard template using openupgradelib.openupgrade for table, column, and model renaming before Odoo ORM models load.

    • post-migration.py: Standard template for data migrations, compute field backfills, and XML data reloading after models load.

    • README.md: Migration execution guide and CLI commands.

  • Safety First (Dry-Run & Auto-Backup):

    • Defaults to dry_run=True, generating git-compatible unified diffs without modifying files on disk.

    • When dry_run=False is specified, creates a timestamped full backup under _migration_backups/<timestamp>/ before applying any changes to disk.

10. Modern OWL & JavaScript Analyzer

The analyze_odoo_owl_component tool inspects custom Odoo frontend files (static/src/**/*.js and static/src/**/*.xml) to ensure compatibility with modern ES modules and Owl 2 (Odoo 16/17/18/19).

Capabilities include:

  • Legacy Framework Detection: Flags obsolete Odoo JavaScript patterns including odoo.define(...), Widget.extend, require("web.Widget"), and require("web.core").

  • ES Module Headers: Verifies that modern JavaScript files declare the mandatory /** @odoo-module **/ header comment for bundling.

  • OWL 2 Patch Modernization: Detects obsolete 3-argument patch(target, "name", {...}) calls and guides migration to modern 2-argument patch(target, {...}) syntax (Odoo 17+).

  • Component & Registry Inspection: Identifies components extending Component and tracks registrations into categories (fields, views, actions, services).

  • QWeb Template Validation: Verifies <templates> root structure, unique t-name declarations, and flags security-deprecated t-raw attributes in favor of t-out.

  • Cross-File Template Resolution: When inspecting a directory or addon, cross-references component static template = "..." declarations against defined <t t-name="..."> templates to catch missing or mistyped template names before runtime.

11. Automated OpenUpgrade Script Generator

The generate_openupgrade_scripts tool generates production-ready OCA OpenUpgrade migration scripts (pre-migration.py, post-migration.py, README.md) in migrations/<target_version>.1.0/ to handle relational schema and database record migrations.

Capabilities include:

  • Pre-Migration Column & Model Renames: Emits concrete openupgradelib.openupgrade.rename_columns() and openupgrade.rename_models() mapping dictionaries to rename tables/columns in PostgreSQL before Odoo ORM models load.

  • Pre-Migration XML ID Renames: Generates openupgrade.rename_xmlids() lists to preserve database record identity when XML views or action IDs change across versions.

  • Post-Migration Selection Key Migrations: Formulates safe, parameterized SQL updates (env.cr.execute(...)) to transform legacy selection field keys into new values.

  • Post-Migration Compute Field Backfills: Produces batch ORM search and recompute code (records._compute_<field>()) to backfill new stored computed fields for historical records.

  • Safety & Idempotency: Defaults to dry_run=True to preview generated Python code without touching disk; provides overwrite=False safeguards to protect existing manual migration scripts from accidental overwrite.

12. Automated Odoo Test Scaffolder

The scaffold_odoo_tests tool inspects an addon's Python models, fields, constraints, business actions, and security access rules to automatically generate comprehensive Odoo TransactionCase automated test suites (tests/test_*.py and tests/__init__.py).

Capabilities include:

  • Model CRUD & Fixture Generation: Scaffolds setUpClass with valid default values for required model fields, along with test_record_creation, test_record_write, and test_record_unlink.

  • Constraint Validation Tests: Detects @api.constrains decorators and generates with self.assertRaises(ValidationError) test methods to verify data integrity guards.

  • Action & Compute Method Tests: Discovers public action methods (action_*) and computed methods (_compute_*), generating verification test cases.

  • Access Rights Verification: Parses security/ir.model.access.csv and scaffolds security permission tests (check_access_rights("read")).

  • Clean Registration & Overwrite Protection: Maintains tests/__init__.py imports, defaults to dry_run=True for safe code previewing, and respects overwrite=False to preserve existing custom test code.

13. Standalone CLI Runner & Pre-Commit Git Hook

The project provides a standalone terminal CLI runner (odoo-developer-assistant and shorthand alias odoo-assistant) that lets developers and CI/CD pipelines run health checks, migrations, and test scaffolding without needing an active LLM or MCP client.

Capabilities include:

  • Terminal Health Checks: Inspect entire addons or individual files directly:

    odoo-developer-assistant check /path/to/addon
    odoo-developer-assistant check views/order_views.xml
    odoo-developer-assistant check models/order.py
    odoo-developer-assistant check static/src/components/counter.js
  • CI / Git Pre-Commit Strict Mode: Exit code 0 on clean/healthy runs, 1 on critical errors (or on warnings with --fail-on-warning), and 2 on invalid inputs.

  • One-Command Git Hook Installation:

    odoo-developer-assistant install-hook

    Installs an executable .git/hooks/pre-commit hook that automatically checks all staged Odoo files before every commit, rejecting broken code.

  • Pre-Commit Framework Integration: Ready-to-use .pre-commit-hooks.yaml for repositories using the standard pre-commit tool.

14. Automated Odoo Code Fixer

The fix_odoo_addon tool automatically detects and fixes common Odoo issues across frontend OWL components, XML views, Python models, and security CSV files.

Strictly following the safety principle of "detect first, preview changes, and modify only with explicit user permission":

  • Dry-run by default (dry_run=True): Performs analysis and returns clean unified diffs without modifying files on disk.

  • Permission required to apply (dry_run=False or --apply): Creates an automatic timestamped backup under _code_fix_backups/<timestamp>/ before writing changes to disk.

  • Supported Fix Domains:

    • Views (views): Converts deprecated <tree> tags to <list>, refactors legacy attrs="..." and states="..." to direct boolean expressions, converts legacy t-raw to t-out, and strips leading/trailing whitespace in <record id="...">.

    • Python Models (models): Strips obsolete @api.multi / @api.one decorators, automatically injects @api.model_create_multi above def create(...), and modernizes fields.Date.to_string() / fields.Datetime.to_string() with native str().

    • Security CSV (security): Prepends the mandatory model_ prefix to raw model names in ir.model.access.csv.

    • Modern OWL & Frontend (owl): Prepends /** @odoo-module **/ to modern ES module components and replaces deprecated t-raw with t-out in QWeb XML templates.

Related MCP server: odoo-analyzer

Standalone CLI & Git Pre-Commit Usage

1. Run Health Checks

# Check an addon directory
odoo-developer-assistant check sample_addons/my_custom_module

# Check a single view or model file
odoo-developer-assistant check tests/fixtures/valid_view.xml

# Fail CI/CD build if any warnings or critical errors are detected
odoo-developer-assistant check /path/to/addon --fail-on-warning

2. Automatically Fix Common Code Issues

# Preview proposed fixes without modifying files (dry run)
odoo-developer-assistant fix /path/to/addon

# Explicitly apply fixes with automatic backup
odoo-developer-assistant fix /path/to/addon --apply

# Restrict fixes to specific domains (e.g., models or views only)
odoo-developer-assistant fix /path/to/addon --domain models --apply

# Health check with automatic fix preview
odoo-developer-assistant check /path/to/addon --fix

# Health check and automatically apply fixes
odoo-developer-assistant check /path/to/addon --fix --apply

3. Scaffold Tests from Terminal

# Preview generated test suites
odoo-developer-assistant scaffold-tests /path/to/addon

# Write test files directly to disk
odoo-developer-assistant scaffold-tests /path/to/addon --apply

4. Run Migrations from Terminal

# Preview Odoo 19 migration diffs
odoo-developer-assistant migrate /path/to/addon --target-version 19.0

# Apply migration and save timestamped backup
odoo-developer-assistant migrate /path/to/addon --target-version 19.0 --apply

5. Install Git Pre-Commit Hook

# Install pre-commit hook into your local git repository
odoo-developer-assistant install-hook

Or add to your repository's .pre-commit-config.yaml:

repos:
  - repo: https://github.com/pks0204/odoo-developer-assistant-mcp
    rev: v0.1.0
    hooks:
      - id: odoo-addon-health-check

Requirements

  • Python 3.12 or a compatible Python version

  • MCP Python SDK 2.3.0

  • MCP Inspector for interactive testing

Installation

Clone or download the repository, then enter the project directory.

Create a virtual environment:

python3 -m venv .venv
source .venv/bin/activate

Install the Python dependency:

python -m pip install -r requirements.txt

Install pytest for development and testing:

python -m pip install pytest

Run the Automated Tests

From the project root:

pytest -v

The current test suite contains 176 tests covering error classification, traceback stack parsing, PostgreSQL constraint diagnostics, Owl 2 crash analysis, addon inspection, manifest pre-flight installation checks, external dependencies verification, sequential data load ordering diagnostics, circular module dependency detection, XML view analysis, Python model analysis, security analysis, standard Odoo core modules & security groups resolution, cross-file consistency, batch live metadata verification & enterprise schema query chunking, addon migration & OpenUpgrade scaffolding, modern OWL & JavaScript component analysis, automated OpenUpgrade script generation, automated test scaffolding, standalone CLI runner, git pre-commit hooks, automated code fixer with dry-run/permission safety, entry points, and edge cases.

Client Configuration

You can connect this MCP server to any MCP-compliant client (Claude Desktop, Cursor, Zed, etc.).

Claude Desktop

Add the following to your Claude Desktop configuration file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Option A: Direct execution with uvx (No local clone needed)

{
  "mcpServers": {
    "odoo-developer-assistant": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/pks0204/odoo-developer-assistant-mcp",
        "odoo-developer-assistant"
      ]
    }
  }
}

Option B: Local Repository

{
  "mcpServers": {
    "odoo-developer-assistant": {
      "command": "/absolute/path/to/odoo-developer-assistant/.venv/bin/odoo-developer-assistant"
    }
  }
}

Cursor / Zed

Configure the command in your editor's MCP settings:

  • Command: odoo-developer-assistant (if installed in PATH or via uvx)

  • Transport: stdio

Example Assistant Prompts

Once configured, you can prompt your AI assistant with queries like:

  • "Audit the health of my custom addon at /path/to/my_module before I install it."

  • "Check this Odoo log traceback and explain the root cause: <paste traceback>"

  • "Inspect the XML view at views/sale_order_views.xml for structural errors or deprecated syntax."

  • "Analyze models/res_partner.py for missing inverse fields or incomplete @api decorators."

  • "Verify my security/ir.model.access.csv permissions file."

  • "Migrate my Odoo 16 module at /path/to/my_addon to Odoo 19: preview the diffs first with dry_run, then scaffold OpenUpgrade database scripts."

  • "Inspect my frontend component at static/src/components/counter.js and its QWeb XML template for modern OWL 2 compatibility."

  • "Generate OpenUpgrade migration scripts for /path/to/my_addon to rename column client_order_ref to customer_reference on sale_order and backfill computed field amount_tax."

  • "Scaffold comprehensive automated unit tests for all models in my addon at /path/to/my_addon, including CRUD, constraints, and access rights."

Run with MCP Inspector

Ensure MCP Inspector is available in your environment.

Start the project using:

./run_inspector.sh

Open the Inspector URL displayed by the command in your browser.

The launcher starts the Inspector with server.py and handles process cleanup when the session ends.

Sample Addon & Fixtures

The sample_addons/my_custom_module directory contains a sample manifest for testing.

Some files referenced by the sample manifest are intentionally absent. This allows the manifest validator to demonstrate how it reports missing files.

The tests/fixtures/ directory provides sample XML view files (valid_view.xml, malformed_view.xml, suspicious_view.xml), a sample Python model file (sample_model.py), and sample security files (ir.model.access.csv, security_rules.xml) for testing and demonstration in MCP Inspector.

Project Structure

odoo-developer-assistant/
├── .github/
│   └── workflows/
│       └── ci.yml
├── .gitignore
├── LICENSE
├── README.md
├── pyproject.toml
├── pytest.ini
├── requirements.txt
├── run_inspector.sh
├── server.py
├── sample_addons/
│   └── my_custom_module/
│       └── __manifest__.py
└── tests/
    ├── fixtures/
    │   ├── ir.model.access.csv
    │   ├── malformed_view.xml
    │   ├── sample_model.py
    │   ├── security_rules.xml
    │   ├── suspicious_view.xml
    │   └── valid_view.xml
    └── test_server.py

Operational Scope & Guarantees

  • Static vs Live Verification: When executed without an active Odoo instance, analysis is static and relies on AST parsing, structure validation, and standard module knowledge bases. When connected to a live database (via verify_odoo_live_metadata or --live-url), the assistant dynamically confirms model existence, database field presence, and external XML IDs in the target environment.

  • Read-Only Safety: The tools strictly do not modify an active Odoo database (live inspection via verify_odoo_live_metadata runs read-only search_read queries).

  • Behavioral Testing: Static checks and live schema audits verify structural and relational integrity; dynamic business logic execution is verified by running the automated unit test cases generated via scaffold_odoo_tests.

Future Improvements

  • Expand automated tests for unusual and edge-case inputs.

License

This project is licensed under the GNU Lesser General Public License v3.0 (LGPL-3.0) — see the LICENSE file for details.

Available Tools

8 tools
analyze_odoo_errorB

Analyze an Odoo error and suggest troubleshooting steps.

Args: error_text: The error message or traceback to investigate.

Inputs: error_text (required).

analyze_odoo_python_modelA

Analyze an Odoo Python model file for structural errors, missing attributes, decorator misconfigurations, and common mistakes using AST.

Args: python_path: Absolute or relative path to the Python file. addon_path: Optional path to the containing addon directory to enforce sandboxed file access.

Inputs: python_path (required), addon_path.

analyze_odoo_securityA

Analyze an Odoo security file (ir.model.access.csv or security XML data) for syntax mistakes, invalid headers, missing model prefixes, and misconfigured rules.

Args: file_path: Absolute or relative path to the security file (.csv or .xml). addon_path: Optional path to the containing addon directory to enforce sandboxed file access.

Inputs: file_path (required), addon_path.

analyze_odoo_xml_viewB

Analyze an Odoo XML data or view file for structural errors, suspicious references, and common issues.

Args: xml_path: Absolute or relative path to the XML file. addon_path: Optional path to the containing addon directory to enforce sandboxed file access.

Inputs: xml_path (required), addon_path.

check_odoo_addon_healthA

Run a comprehensive static health audit for an entire Odoo addon directory, evaluating the manifest, dependencies, XML views, Python models, and security rules.

Args: addon_path: Absolute or relative path to the Odoo addon directory. addons_directories: Optional list of directory paths containing other addons to check module dependencies against.

Inputs: addon_path (required), addons_directories.

inspect_odoo_moduleB

Inspect an Odoo addon manifest and check dependencies across multiple addons directories.

Args: addon_path: Absolute path to the addon directory. addons_directories: Absolute paths to directories containing Odoo addons, such as standard, enterprise, and custom addons.

Inputs: addon_path (required), addons_directories (required).

validate_odoo_manifestB

Validate an Odoo addon's manifest and declared data/demo files.

Checks manifest syntax, important fields, and whether files declared in 'data' and 'demo' exist inside the addon directory.

Args: addon_path: Absolute path to the Odoo addon directory.

Inputs: addon_path (required).

verify_odoo_live_metadataA

Connect to a running Odoo instance via read-only XML-RPC to dynamically verify whether models, model fields, and external XML IDs exist in the active database.

Args: url: URL of the Odoo instance (e.g. 'http://localhost:8069' or 'https://myodoo.example.com'). db: Name of the Odoo database. username: User login name / email. password: User password or API key. models_to_check: Optional list of model names to verify (e.g. ['sale.order', 'res.partner']). fields_to_check: Optional mapping of model names to lists of field names to verify (e.g. {'sale.order': ['partner_id', 'custom_ref']}). xml_ids_to_check: Optional list of external XML IDs to verify (e.g. ['base.group_user', 'sale.action_orders']). timeout: Network timeout in seconds (default: 10).

Inputs: db (required), url (required), password (required), username (required), +4 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 8 tools

    Disambiguation3/5

    The per-file analyzers (XML, Python, security) are clearly distinct, but inspect_odoo_module, validate_odoo_manifest, and check_odoo_addon_health all take the same addon_path argument and examine manifest/dependency concerns, with health subsuming the other two. An agent must read descriptions carefully to choose between inspect vs validate vs the full health audit.

    Naming Consistency5/5

    Every tool follows a predictable verb_odoo_noun snake_case pattern (analyze_*, inspect_*, validate_*, check_*, verify_*) and uses 'odoo' as the consistent domain token. No mixed conventions or casing irregularities.

    Tool Count5/5

    Eight tools is well within the sweet spot and each maps to a distinct artifact type or workflow stage (manifest, XML, Python, security, error, aggregate audit, live verification). Nothing feels padded or missing at the count level.

    Completeness4/5

    The surface covers static analysis across the major addon artifact types plus an aggregate health audit and live XML-RPC verification, which is strong lifecycle coverage for a developer assistant. Gaps remain: no scaffolding/module creation, no JS/OWL asset analysis, no automated fix application, and no i18n or test-related checks.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to interact with Odoo databases via XML-RPC and JSON-RPC for performing CRUD operations and managing modules. It supports advanced features like domain-based searching, field metadata inspection, and administrative task execution.
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      AI-powered Odoo engineering platform providing static analysis, domain knowledge, and 14 MCP tools for code review, model exploration, and security auditing of Odoo modules.
      18 npm
      MIT