Skip to main content
Glama
Odoo Index MCP

Odoo Index MCP

by letzdoo

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 sync

Usage

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 sale

MCP Server

# Start MCP server
uv run odoo-index-mcp

Claude 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 type

  • module (str, optional): Filter by module

  • parent_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 item

  • name (str): Item name

  • parent_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 item

  • name (str): Item name

  • reference_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 search

  • attribute_filters (dict): Attribute filters

  • module (str, optional): Filter by module

  • limit (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 module

  • limit (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=8

Project 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 parsing

Database Schema

The index uses a normalized SQLite schema with 3 main tables:

  1. indexed_items: Core item data (type, name, module, attributes JSON)

  2. item_references: File locations (many-to-one with items)

  3. 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:

  1. Fork the repo

  2. Create a feature branch

  3. Add tests for new functionality

  4. 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 tools
find_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

    A4.1/5.0

    Scored across 9 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    All tools follow a consistent verb_noun snake_case pattern (e.g., search_odoo_index, get_item_details, find_references). No deviations.

    Tool Count5/5

    With 9 tools, the set is well-scoped for an Odoo index server. Each tool serves a clear purpose without unnecessary bloat or gaps.

    Completeness4/5

    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

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables 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.
      7
      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
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI coding assistants to semantically search and retrieve relevant code patterns, documentation, and implementations from a codebase via MCP tools.
      8
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI coding agents to efficiently explore codebases by providing structural outlines, module digests, symbol bodies, and AST-aware grep via MCP.
      4
      14 npm
      1
      MIT