Odoo Index MCP
Indexes Odoo code elements such as models, fields, views, menus, actions, and more, providing fast search and reference lookup for Odoo development.
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 Index MCP search for model sale.order"
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 Index MCP
A lightweight MCP (Model Context Protocol) server for indexing Odoo code elements. Designed to help coding agents quickly look up models, fields, functions, views, and other Odoo components with their exact file locations.
Features
Fast Indexing: Uses AST parsing for Python and lxml for XML
Incremental Updates: Only re-indexes changed files (MD5 hash tracking)
Comprehensive Coverage: Indexes models, fields, methods, views, menus, actions, access rights, rules, scheduled actions, report templates, controller routes, and more
Multiple References: Tracks all occurrences (definition, inheritance, override, etc.)
Lightweight: Pure SQLite, no vector DB, no embeddings
MCP Compatible: Works with Claude Desktop and other MCP clients
Related MCP server: odoo-analyzer
What Gets Indexed
Core Elements
Models: Name, type (regular/transient/abstract), inheritance
Fields: Name, type, attributes (required, readonly, compute, related, etc.)
Functions/Methods: Name, decorators (@api.depends, @api.onchange, etc.)
Views: Type (form/tree/kanban/search), model, inheritance
Menus: Hierarchy, actions, security groups
Actions: Type (act_window/server/report), models, domains
Access Rights: Model permissions by security group
Record Rules: Domain-based access rules
Controller Routes: HTTP/JSON routes with auth types
Scheduled Actions: Cron jobs with intervals
Report Templates: QWeb templates
Module Metadata: Dependencies, version, description
Multiple References
Each element can have multiple file:line references:
definition: Where it's originally defined
inheritance: Where models are extended
override: Where methods/fields are overridden
reference: Where it's referenced
modification: Where views are modified with xpath
Installation
Prerequisites
Python 3.10+
uv package manager
Setup
# Clone or navigate to the project
cd odoo-index-mcp
# Create .env file
cp .env.example .env
# Edit .env and set your ODOO_PATH
nano .env
# Install dependencies with uv
uv syncUsage
CLI Tool
# Full indexing
uv run python cli.py --index
# Incremental indexing (skip unchanged files)
uv run python cli.py --index --incremental
# Index specific modules
uv run python cli.py --index --modules sale,account,stock
# Clear database and re-index
uv run python cli.py --clear --index
# Show statistics
uv run python cli.py --stats
# Search from CLI
uv run python cli.py --search "sale.order" --type model
uv run python cli.py --search "partner_id" --type field --module sale
# Search XML IDs
uv run python cli.py --search-xml-id "action_view_%"
uv run python cli.py --search-xml-id "action_view_sale_order" --module saleMCP Server
# Start MCP server
uv run odoo-index-mcpClaude Desktop Integration
Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"odoo-index": {
"command": "uv",
"args": ["run", "odoo-index-mcp"],
"cwd": "/path/to/odoo-index-mcp",
"env": {
"ODOO_PATH": "/path/to/odoo"
}
}
}
}MCP Tools
The server provides 7 MCP tools:
1. search_odoo_index
Search for elements by name with wildcard support.
Parameters:
query(str): Search term (supports SQL LIKE with %)item_type(str, optional): Filter by typemodule(str, optional): Filter by moduleparent_name(str, optional): Filter by parent (for fields/methods)limit(int, default=50): Max results
Example:
search_odoo_index(query="sale.order", item_type="model")
search_odoo_index(query="partner%", item_type="field", module="sale")2. get_item_details
Get complete details for a specific element including related items.
Parameters:
item_type(str): Type of itemname(str): Item nameparent_name(str, optional): Parent (for fields/methods)module(str, optional): Module to disambiguate
Example:
get_item_details(item_type="model", name="sale.order")
get_item_details(item_type="field", name="partner_id", parent_name="sale.order")3. list_modules
List all indexed modules with item counts.
Parameters:
pattern(str, optional): Filter by name pattern
Example:
list_modules()
list_modules(pattern="sale")4. get_module_stats
Get detailed statistics for a module.
Parameters:
module(str): Module name
Example:
get_module_stats(module="sale")5. find_references
Find all references to an element across the codebase.
Parameters:
item_type(str): Type of itemname(str): Item namereference_type(str, optional): Filter by type (definition/inheritance/etc)
Example:
find_references(item_type="model", name="sale.order")
find_references(item_type="model", name="sale.order", reference_type="inheritance")6. search_by_attribute
Advanced search by element attributes.
Parameters:
item_type(str): Type to searchattribute_filters(dict): Attribute filtersmodule(str, optional): Filter by modulelimit(int, default=50): Max results
Example:
# Find all Many2one fields
search_by_attribute(
item_type="field",
attribute_filters={"field_type": "Many2one"}
)
# Find all transient models (wizards)
search_by_attribute(
item_type="model",
attribute_filters={"model_type": "transient"}
)
# Find all form views
search_by_attribute(
item_type="view",
attribute_filters={"view_type": "form"}
)7. search_xml_id
Search for XML IDs by name pattern.
Parameters:
query(str): Search term (supports SQL LIKE patterns with %)module(str, optional): Filter by modulelimit(int, default=50): Max results
Example:
# Find all action_view XML IDs
search_xml_id(query="action_view_%")
# Find specific action
search_xml_id(query="action_view_sale_order")
# Find form views in sale module
search_xml_id(query="%_form_view", module="sale")Performance
Indexing Speed: ~500-1000 files/second with concurrent processing and async database operations
Database Size: ~50-100MB for typical Odoo installation
Search Speed: <50ms for exact match, <200ms for pattern search
Memory Usage: <500MB during indexing, <100MB when serving
Database: Async connection pooling with aiosqlite for efficient concurrent writes
Configuration
Environment variables in .env:
# Required
ODOO_PATH=/path/to/odoo
# Optional (with defaults)
SQLITE_DB_PATH=./odoo_index.db
LOG_LEVEL=INFO
MAX_CONCURRENT_MODULES=4
MAX_CONCURRENT_FILES=8Project Structure
odoo-index-mcp/
├── pyproject.toml # uv project config
├── .env.example # Environment template
├── .python-version # Python version
├── README.md # This file
├── cli.py # CLI tool
├── odoo_index_mcp/
│ ├── __init__.py
│ ├── config.py # Configuration
│ ├── database.py # SQLite operations
│ ├── indexer.py # Main indexing logic
│ ├── server.py # FastMCP server
│ ├── tools.py # MCP tool implementations
│ └── parsers/
│ ├── __init__.py
│ ├── python_parser.py # AST parsing for Python
│ ├── xml_parser.py # XML parsing for views/data
│ ├── csv_parser.py # CSV parsing for access rights
│ └── manifest_parser.py # Manifest file parsingDatabase Schema
The index uses a normalized SQLite schema with 3 main tables:
indexed_items: Core item data (type, name, module, attributes JSON)
item_references: File locations (many-to-one with items)
file_metadata: File hashes for incremental indexing
All queries use proper indexes for fast lookups.
Development
# Install development dependencies
uv sync
# Run tests (TODO: add tests)
uv run pytest
# Format code
uv run black .
# Type checking
uv run mypy .License
MIT
Contributing
Contributions welcome! Please:
Fork the repo
Create a feature branch
Add tests for new functionality
Submit a pull request
Support
For issues or questions:
Open an issue on GitHub
Check the documentation in ODOO_CODE_INDEXER.md
Roadmap
Future enhancements (not in v1):
Call graph analysis
Full-text search in method bodies
Dependency graph visualization
Watch mode (auto-reindex on changes)
Web UI for browsing
Export to other formats
Available Tools
9 toolsfind_referencesB
Find all references to a specific Odoo element across the codebase.
Args: item_type: Type of item (model/field/function/view/etc) name: Item name reference_type: Filter by reference type (definition/inheritance/override/reference/modification)
Returns: All file locations where this item is referenced
Inputs: name (required), item_type (required), reference_type. Returns: object
get_index_statusA
Get the current status of the index and any ongoing indexing operations.
Returns information about:
Database location
Whether indexing is currently running
Total number of indexed items
Number of modules indexed
Breakdown by item type
Indexing progress (if running)
Returns: Status information including database path, item counts and indexing state
Inputs: no named parameters. Returns: object
get_item_detailsA
Get FULL details for a specific Odoo element.
WARNING: This returns ALL information including ALL references, ALL fields, ALL methods, ALL views, etc. for models. Use search_odoo_index() for quick lookups.
Use this ONLY when you specifically need:
All references (inheritance, overrides, usages)
All fields/methods of a model
All views/actions related to a model
Full attribute details
Args: item_type: Type of item (model/field/function/view/menu/action/etc) name: Item name (e.g., 'sale.order' for model, 'partner_id' for field) parent_name: Parent name (required for fields/methods - the model name) module: Module name (optional, helps disambiguate)
Returns: Complete item details with all references and related items
Inputs: name (required), item_type (required), module, parent_name. Returns: object
get_module_statsA
Get detailed statistics for a specific Odoo module.
Args: module: Module name (e.g., 'sale', 'account', 'stock')
Returns: Module statistics including counts by item type
Inputs: module (required). Returns: object
list_modulesA
List all indexed Odoo modules.
Args: pattern: Filter by module name pattern (optional)
Returns: List of modules with item counts
Inputs: pattern. Returns: object
search_by_attributeA
Search Odoo elements by their attributes (advanced filtering).
Args: item_type: Type of item to search (model/field/view/action/etc) attribute_filters: Dict of attribute filters (e.g., {"field_type": "Many2one", "required": true}) module: Filter by module (optional) limit: Maximum results per page (default: 20, max: 100) offset: Number of results to skip for pagination (default: 0)
Returns: Matching items with their details and pagination info
Examples: - Find all Many2one fields: item_type="field", attribute_filters={"field_type": "Many2one"} - Find all transient models: item_type="model", attribute_filters={"model_type": "transient"} - Find all form views: item_type="view", attribute_filters={"view_type": "form"}
Inputs: item_type (required), attribute_filters (required), limit, module, +1 more. Returns: object
search_odoo_indexA
Search for indexed Odoo elements by name (returns CONCISE results).
This tool returns minimal, essential information only:
name, type, module, file, line number
Key attributes (description, field_type, etc.)
Results are sorted by relevance (exact matches first, then by dependency depth). The most relevant results are typically in the first 5 items.
Use get_item_details() if you need full details about a specific item.
PAGINATION: Results include 'has_more' and 'next_offset' fields. If has_more=true, call again with offset=next_offset to get more results.
Args: query: Search term (supports SQL LIKE patterns with %) item_type: Filter by type (model/field/function/view/menu/action/etc) module: Filter by module name parent_name: Filter by parent (e.g., model name for fields/methods) limit: Maximum results per page (default: 5, max: 50) offset: Number of results to skip for pagination (default: 0)
Returns: { total: Total matching items, returned: Number of items in this page, has_more: Whether more results are available, next_offset: Offset to use for next page (null if no more), results: Array of concise item data }
Inputs: query (required), limit, module, offset, +2 more. Returns: object
search_xml_idA
Search for XML IDs by name pattern.
This tool searches across all Odoo elements that have XML IDs (views, actions, menus, rules, scheduled actions, report templates, and other data records).
Args: query: Search term (supports SQL LIKE patterns with %, e.g., 'action_view_%') module: Filter by module name (optional) limit: Maximum results per page (default: 20, max: 100) offset: Number of results to skip for pagination (default: 0)
Returns: XML IDs with their details including item type, model, file location, line numbers, and pagination info
Examples: - Find all action views: query="action_view_%" - Find specific action: query="action_view_sale_order" - Find form views: query="%_form_view"
Inputs: query (required), limit, module, offset. Returns: object
update_indexA
Update the Odoo index by scanning and parsing the codebase.
This tool triggers a re-indexing of the Odoo codebase in the background. By default, it performs incremental indexing (only re-parsing changed files). The function returns immediately while indexing continues in the background.
Args: incremental: If True, skip unchanged files (default: True). Set to False for full re-index. modules: Comma-separated list of module names to index (e.g., "sale,account,stock"). If not provided, all modules will be indexed. clear_db: If True, clear the entire database before indexing (default: False). WARNING: This will delete all existing index data!
Returns: Status message confirming indexing has started
Examples: - Incremental update: update_index() - Full re-index: update_index(incremental=False) - Index specific modules: update_index(modules="sale,account") - Clear and re-index: update_index(clear_db=True, incremental=False)
Inputs: modules, clear_db, incremental. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool targets a distinct operation: concise search, full details, module listing, stats, references, attribute-based search, XML ID search, index update, and status. No overlap in functionality.
All tools follow a consistent verb_noun snake_case pattern (e.g., search_odoo_index, get_item_details, find_references). No deviations.
With 9 tools, the set is well-scoped for an Odoo index server. Each tool serves a clear purpose without unnecessary bloat or gaps.
The tools cover all essential query types (search, details, stats, references, attribute search, XML ID search) and index management (update, status). Minor gap: no tool for deleting specific index items, but that's administrative.
Related MCP Connectors
Search and inspect source-pinned agent skills, plugins and tools through a free public MCP.
Search MCP servers, agent skills and AI tools by task. Read-only, no API key.
Search and fetch AI agent skills, rules files and MCP servers indexed from GitHub.
Search a directory of 70K+ AI building blocks: MCP servers, agents, models, datasets, prompts.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to search code by meaning, explore codebase structure, store and query knowledge with temporal facts, and read source code through a set of MCP tools.7MIT
- 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
- AlicenseNot gradedqualityDmaintenanceEnables AI coding assistants to semantically search and retrieve relevant code patterns, documentation, and implementations from a codebase via MCP tools.8MIT
- AlicenseAqualityCmaintenanceEnables AI coding agents to efficiently explore codebases by providing structural outlines, module digests, symbol bodies, and AST-aware grep via MCP.414 npm1MIT