Odoo Developer Assistant MCP
An MCP server for Odoo developer assistance: it statically analyzes Odoo code/configuration and can read-only verify metadata against a live Odoo instance.
Analyze Odoo runtime error text/tracebacks and suggest root causes and fixes.
Inspect an addon's
__manifest__.pyand check dependencies across supplied addon directories.Validate manifest fields and declared
data/demofiles.Analyze Odoo XML view/data files for structural and reference issues.
Analyze Odoo Python model files via AST for model, field, and decorator problems.
Analyze Odoo security CSV/XML for header, permission, rule, and integrity issues.
Run a comprehensive addon health audit across manifest, dependencies, views, models, security, and cross-file consistency.
Connect to a live Odoo database via read-only XML-RPC to verify models, fields, and external XML IDs.
Provides tools for Odoo development and troubleshooting: classifies common Odoo error tracebacks, statically inspects addon manifests and dependencies, validates manifest fields and referenced data files, analyzes XML view/data files and Python model files for structural errors, audits security files (ir.model.access.csv and ir.rule XML), runs a consolidated addon health check with cross-file consistency scoring, and connects read-only via XML-RPC to a live Odoo instance to verify models, fields, and external XML IDs before deployment.
Click on "Deploy 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., "@Odoo Developer Assistant MCP analyze this Odoo error: invalid XML ID in my custom view"
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.
Odoo Developer Assistant MCP
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 NULLconstraint violations (identifying exact column and table), duplicate keyUNIQUEviolations (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 (accessingthis.envoutsidesetup()).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
dataanddemoexist on disk, with confinement checks against path traversal or symlink escapes.External Dependencies Verification: Inspects
external_dependenciesto 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 exactpip install <pkg>recommendations.Sequential Data Load Order: Detects unsafe load ordering in
'data'(e.g., view files declared beforesecurity/ir.model.access.csvor sequence files) to prevent install-timeParseError: External ID not foundcrashes.Dependency Guard: Flags self-dependencies (
addondepending 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
idandmodelattributes on<record>tags, flags whitespace in IDs, and detects duplicate record IDs across the file.View Architecture Inspection: Verifies that
ir.ui.viewrecords define non-empty<field name="arch" type="xml">blocks.External ID Reference Extraction: Extracts
refattributes andref('...')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_pathconfinement 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, ormodels.AbstractModel.Model Attribute Validation: Checks for
_name,_inherit, and flags new models missing a_descriptionattribute.Relational Field Checks: Flags
fields.Many2oneorfields.Many2manymissing comodel names, andfields.One2manymissing inverse field names.On-delete Validation: Warns about suspicious
ondeleteconfigurations onMany2onefields.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_pathsandboxing.
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:idhas the mandatorymodel_prefix (e.g.model_custom_order, notcustom.order).Binary Permission Flags: Validates that all permission columns (
perm_read,perm_write,perm_create,perm_unlink) are strictly0or1.Integrity Checks: Detects duplicate access rule IDs and column count mismatches.
Global Rule Detection: Identifies rules with empty
group_id:idthat grant global permissions across all users.Security XML Analysis: Validates
ir.rulerecord definitions to ensuremodel_idanddomain_forceare 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.csvand 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_pathto 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.modelto check whether referenced models exist in the target database.Field Verification: Queries
ir.model.fieldsto verify that field names, types (ttype), and attributes exist on the target model.External XML ID Verification: Queries
ir.model.datato 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_readcalls; 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 legacyattrs="{...}"dictionaries into direct Python expressions (invisible="...",readonly="...",required="..."), and transformsstates="..."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_multiand provides batch-compatiblevals_listsignatures.Flags deprecated ORM calls (e.g.
fields.Date.to_string,fields.Datetime.from_string, obsolete_name_searchsignatures).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
versiondeclarations in__manifest__.pyto target version19.0.x.xwhile preserving custom sub-versioning formats.OpenUpgrade Database Scaffolding: Automatically scaffolds OCA standard
migrations/19.0.1.0/structure including:pre-migration.py: Standard template usingopenupgradelib.openupgradefor 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=Falseis 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"), andrequire("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-argumentpatch(target, {...})syntax (Odoo 17+).Component & Registry Inspection: Identifies components extending
Componentand tracks registrations into categories (fields,views,actions,services).QWeb Template Validation: Verifies
<templates>root structure, uniquet-namedeclarations, and flags security-deprecatedt-rawattributes in favor oft-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()andopenupgrade.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=Trueto preview generated Python code without touching disk; providesoverwrite=Falsesafeguards 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
setUpClasswith valid default values for required model fields, along withtest_record_creation,test_record_write, andtest_record_unlink.Constraint Validation Tests: Detects
@api.constrainsdecorators and generateswith 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.csvand scaffolds security permission tests (check_access_rights("read")).Clean Registration & Overwrite Protection: Maintains
tests/__init__.pyimports, defaults todry_run=Truefor safe code previewing, and respectsoverwrite=Falseto 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.jsCI / Git Pre-Commit Strict Mode: Exit code
0on clean/healthy runs,1on critical errors (or on warnings with--fail-on-warning), and2on invalid inputs.One-Command Git Hook Installation:
odoo-developer-assistant install-hookInstalls an executable
.git/hooks/pre-commithook that automatically checks all staged Odoo files before every commit, rejecting broken code.Pre-Commit Framework Integration: Ready-to-use
.pre-commit-hooks.yamlfor repositories using the standardpre-committool.
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=Falseor--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 legacyattrs="..."andstates="..."to direct boolean expressions, converts legacyt-rawtot-out, and strips leading/trailing whitespace in<record id="...">.Python Models (
models): Strips obsolete@api.multi/@api.onedecorators, automatically injects@api.model_create_multiabovedef create(...), and modernizesfields.Date.to_string()/fields.Datetime.to_string()with nativestr().Security CSV (
security): Prepends the mandatorymodel_prefix to raw model names inir.model.access.csv.Modern OWL & Frontend (
owl): Prepends/** @odoo-module **/to modern ES module components and replaces deprecatedt-rawwitht-outin 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-warning2. 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 --apply3. 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 --apply4. 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 --apply5. Install Git Pre-Commit Hook
# Install pre-commit hook into your local git repository
odoo-developer-assistant install-hookOr 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-checkRequirements
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/activateInstall the Python dependency:
python -m pip install -r requirements.txtInstall pytest for development and testing:
python -m pip install pytestRun the Automated Tests
From the project root:
pytest -vThe 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.jsonLinux:
~/.config/Claude/claude_desktop_config.jsonWindows:
%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 viauvx)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_modulebefore I install it.""Check this Odoo log traceback and explain the root cause:
<paste traceback>""Inspect the XML view at
views/sale_order_views.xmlfor structural errors or deprecated syntax.""Analyze
models/res_partner.pyfor missing inverse fields or incomplete @api decorators.""Verify my
security/ir.model.access.csvpermissions file.""Migrate my Odoo 16 module at
/path/to/my_addonto Odoo 19: preview the diffs first with dry_run, then scaffold OpenUpgrade database scripts.""Inspect my frontend component at
static/src/components/counter.jsand its QWeb XML template for modern OWL 2 compatibility.""Generate OpenUpgrade migration scripts for
/path/to/my_addonto rename columnclient_order_reftocustomer_referenceonsale_orderand backfill computed fieldamount_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.shOpen 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.pyOperational 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_metadataor--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_metadataruns read-onlysearch_readqueries).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 toolsanalyze_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
Scored across 8 tools
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.
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.
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.
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
Related MCP Connectors
30+ deterministic dev and delivery tools: linting, metrics, diagrams, model advice, AI-text checks.
Exact developer checks: email DNS, Supabase RLS, cron, JSON, contrast, time zones, npm/PyPI packages
Free, read-only ship-readiness check for Replit, Lovable and Bolt apps.
Detects database migration table locks, terraform cost leaks, and OWASP API flaws.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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
- AlicenseNot gradedqualityAmaintenanceAI-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 npmMIT
- AlicenseAqualityDmaintenanceEnables analyzing Salesforce deployment logs, validating metadata manifests, assessing permission risks, and generating remediation plans through deterministic, local-only rules.4MIT
- FlicenseNot gradedqualityAmaintenanceEnables 1C:Enterprise development with 74 tools for static analysis, code audit, query validation, EPF verification, and configuration management using local XML exports without a running database.2-