Provides tools for interacting with Odoo ERP, including searching, reading, counting, and introspecting models, as well as business tools like overdue invoices, sales summary, low-stock products, and top customers. Optionally supports creating, updating, and deleting records when writes are enabled.
Click on "Install 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 MCP Server Show me the overdue invoices"
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.
A Model Context Protocol server for Odoo. Connect Claude (or any MCP client) to your own Odoo ERP and query, report on, and optionally modify your data in natural language.
Works with any Odoo model. Safe by default: read-only unless you explicitly enable writes. Your credentials stay on your machine — nothing is stored or sent anywhere except your own Odoo instance.
🔍 Generic access to any model — search, read, count, introspect fields, list models
📊 Ready-made business tools — overdue invoices, sales summary, low-stock products, top customers
🔒 Read-only by default — create/update/delete only when you opt in (ODOO_ENABLE_WRITES=true)
🔑 Your data, your machine — configured entirely through environment variables
Related MCP server: Odoo MCP Server
Add this to your MCP client config (e.g. Claude Desktop or Claude Code):
{
"mcpServers": {
"odoo": {
"command": "npx",
"args": ["-y", "odoo-mcp-connector"],
"env": {
"ODOO_URL": "https://your-company.odoo.com",
"ODOO_DB": "your-database",
"ODOO_USERNAME": "you@example.com",
"ODOO_API_KEY": "your-odoo-api-key"
}
}
}
}In Odoo: Settings → Users → (your user) → Account Security → New API Key. Paste the generated key into ODOO_API_KEY. (A password also works, but an API key is safer and revocable.)
Read-only is the default. To let the model create, update, or delete records, add:
"ODOO_ENABLE_WRITES": "true"⚠️ Odoo holds real business data. Enable writes only when you accept that the model can create, modify, or delete records — always within your Odoo user's own permissions.
Tool | Purpose |
| Search + read records from any model |
| Read records by ID |
| Count records matching a domain |
| Introspect a model's fields (name, type, label) |
| List available models |
| Unpaid customer invoices past their due date |
| Revenue + order count over a date range |
| Products at/below a quantity threshold |
| Top customers by invoiced revenue |
ODOO_ENABLE_WRITES=trueTool | Purpose |
| Create a record |
| Update records by ID |
| Delete records by ID (irreversible) |
| Call an arbitrary model method |
Variable | Required | Default | Description |
| yes | — | Your Odoo base URL |
| yes | — | Database name |
| yes | — | Login (email) |
| yes | — | API key (or password) |
| no |
| Set |
| no |
| Per-request timeout (ms) |
npm install
npm test # vitest — fully mocked, no live Odoo needed
npm run buildMIT © Falak Sarhan Saade
Count records matching a domain.
| Name | Required | Description | Default |
|---|---|---|---|
| model | Yes | ||
| domain | No | Search domain. Omit to count all records. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as permissions required, performance implications, or potential side effects. The description is minimal and leaves the agent uninformed about important constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise but lacks structure. It could include additional critical information without becoming overly long, so it scores moderately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no output schema and no annotations, the description should at least indicate the return type (e.g., an integer count) or any limitations. It fails to provide a complete picture, leaving the agent to guess the result format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%: the 'model' parameter lacks any description, and the 'domain' parameter has a minimal description ('Search domain. Omit to count all records.'). The tool description adds no additional meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states 'Count records matching a domain' which clearly identifies the verb (count) and resource (records). It distinguishes from sibling tools like odoo_search_read which retrieves data rather than counting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as odoo_search_read or odoo_read. There is no mention of prerequisites, context, or situations where counting is preferable to reading.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Introspect a model's fields — names, types, labels, relations. Useful before querying an unfamiliar model.
| Name | Required | Description | Default |
|---|---|---|---|
| model | Yes | ||
| attributes | No | Which field attributes to return. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates a non-destructive, read-only operation (introspecting fields). With no annotations provided, the description adequately conveys that it is safe to call. However, it does not disclose potential side effects, rate limits, or response behavior beyond listing attributes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise: two sentences that cover the function and usage context without any extraneous words. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description must cover essential behavioral and parameter details. It explains the purpose and usage context adequately but lacks detail on parameter values and return format. For a simple introspection tool, it is minimally complete but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has two parameters: 'model' (undocumented in schema) and 'attributes' (described as 'Which field attributes to return'). The description mentions 'names, types, labels, relations' as possible returns, but does not clarify valid values for the 'attributes' parameter or the format of the 'model' parameter. With only 50% schema coverage, the description should compensate but does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Introspect a model's fields — names, types, labels, relations.' This specifies the verb (introspect), resource (model's fields), and the type of information returned. It also distinguishes itself from sibling data-retrieval tools like odoo_read and odoo_search_read, which operate on records rather than field metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage context: 'Useful before querying an unfamiliar model.' This implies the tool is for preliminary investigation. However, it does not explicitly state when not to use it or mention alternatives, such as using odoo_list_models for model discovery.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available Odoo models, optionally filtered by a substring of the technical name.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Substring to match the model technical name, e.g. 'account'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, authentication requirements, or response format. The action 'list' implies a read operation but lacks details on side effects or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the purpose and optional filter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is minimal. It does not explain the return format, pagination, or error handling. For a simple list tool it is adequate but incomplete for richer context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a detailed schema description for the single 'filter' parameter. The tool description merely echoes the substring filtering idea without adding new meaning, so it scores at the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'List available Odoo models' and the optional filter by substring. It is specific and distinguishes from sibling tools like odoo_fields (which lists fields) or odoo_search_read (which searches records).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like odoo_fields or odoo_count. No explicit context or exclusions are given, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List storable products at or below a quantity threshold — restock alerts.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max products (default 100). | |
| threshold | No | Flag products with on-hand quantity ≤ this (default 5). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It only states the basic operation without disclosing behavioral traits such as read-only nature, pagination, error handling, or permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the key action and resource. It is brief but not under-specified, though a bit more context could be added without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description does not explain return values. For a simple list tool it is minimally adequate, but lacks details on default sorting, response structure, or behavior with no matching products.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both parameters documented). The description mentions 'quantity threshold' which maps to the threshold parameter but adds no additional meaning beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies the verb 'List' and the resource 'storable products' with a clear condition 'at or below a quantity threshold'. It also adds context with 'restock alerts', distinguishing it from sibling tools like generic search or read.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for checking low stock but does not explicitly state when to use this tool versus alternatives or when not to use it. No guidance on context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List unpaid customer invoices past their due date — an instant accounts-receivable / cash-flow view.
| Name | Required | Description | Default |
|---|---|---|---|
| as_of | No | Reference date YYYY-MM-DD for 'overdue' (default: today). | |
| limit | No | Max invoices (default 50). | |
| partner_id | No | Filter to a single customer by partner ID. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states 'instant' and 'view', implying read-only but not explicitly. No disclosure of side effects, rate limits, or data freshness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with key information front-loaded. Efficient but could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a straightforward list tool with well-documented parameters, but lacks explanation of return format or how output can be used. No output schema makes this gap notable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema provides 100% coverage with parameter descriptions; the tool description adds no extra semantic context beyond what the schema already offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the action ('List unpaid customer invoices past their due date') and the resource ('accounts-receivable / cash-flow view'), distinguishing it from sibling tools like odoo_search_read or odoo_read which are more general.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., odoo_search_read for overdue invoices). Does not mention prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read specific records by their IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| ids | Yes | Record IDs to read. | |
| model | Yes | ||
| fields | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavior. It only says 'read', but doesn't disclose read-only nature, potential errors, or any side effects. This is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short (one sentence), which is concise, but it lacks important context, making it more under-specified than efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, no annotations, and low parameter coverage, the description is incomplete. It doesn't explain return values, field selection, or model specification.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 33% (only 'ids' has description). The description adds no parameter detail beyond what's in the schema, failing to compensate for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the verb 'read' and resource 'specific records by their IDs', but it doesn't specify the context (Odoo models) or differentiate from sibling tools like odoo_search_read.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The sibling list includes odoo_search_read, but the description provides no comparison or context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Total revenue and order count over a date range, from sales orders (default) or POS orders.
| Name | Required | Description | Default |
|---|---|---|---|
| source | No | 'sale' = sale.order (default), 'pos' = pos.order. | |
| date_to | Yes | End date YYYY-MM-DD (inclusive). | |
| date_from | Yes | Start date YYYY-MM-DD (inclusive). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds useful context (default source, inclusive dates) but does not disclose output format or whether it is read-only. Since annotations are absent, more detail on behavior (e.g., no destructive action) would help.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no unnecessary words, efficiently communicates the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description mentions output (total revenue and order count) but lacks details on format (single object, two fields?), currency, or whether calculations are based on confirmed orders. Adequate for basic understanding but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already covers parameters with descriptions (100% coverage). The description adds value by explaining the overall purpose and default source, but does not significantly enhance individual parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it computes total revenue and order count over a date range, with source selection (sale or POS). It distinguishes this aggregate tool from sibling tools like odoo_search_read or odoo_overdue_invoices.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (for summary metrics over a date range) and notes the default source. It does not explicitly exclude alternatives, but sibling names make the distinction clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search and read records from any Odoo model in one call. Returns matching records with the requested fields.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max records (default 50). | |
| model | Yes | Model technical name, e.g. 'res.partner', 'sale.order', 'account.move'. | |
| order | No | Sort spec, e.g. 'create_date desc'. | |
| domain | No | Odoo search domain, e.g. [["is_company","=",true]]. Omit for all records. | |
| fields | No | Field names to return. Omit for all fields. | |
| offset | No | Records to skip (default 0). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavioral traits. It only states the operation and return type, omitting safety (read-only nature), potential side effects, pagination behavior, or authentication requirements. The description adds little beyond the name and schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that immediately conveys purpose. No redundant words. Perfectly concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 6 parameters and no output schema, the description combined with the detailed schema (e.g., domain example, limit default) provides sufficient context. However, it could note that it is non-destructive or mention the default page size. Almost complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (all parameters have descriptions in the input schema). The tool description adds no additional parameter-level detail, so it meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Search and read records'), the resource ('any Odoo model'), and the outcome ('Returns matching records with the requested fields'). It differentiates from sibling tools like odoo_read (single record by ID) by emphasizing the combined search and read capability in one call.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs. alternatives (e.g., odoo_read for exact ID lookups, odoo_count for just counting, or odoo_fields for schema). It does not specify prerequisites, limitations, or cases where it should not be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Top customers ranked by invoiced revenue over a date range.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many customers to return (default 10). | |
| date_to | Yes | End date YYYY-MM-DD (inclusive). | |
| date_from | Yes | Start date YYYY-MM-DD (inclusive). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does not disclose that the tool is read-only, lacks destructive side effects, or whether special permissions are required. While the tool name implies a query, the description omits these behavioral details, which is a gap for safe usage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no redundant words. It front-loades the core purpose immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple query tool with three parameters and no output schema, the description covers the core function but lacks details on return format (e.g., fields provided), pagination, or behavioral safety. An agent may need additional context to fully understand the tool's output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers all parameters with descriptions (100% coverage). The description adds value by explaining that the date range filters invoiced revenue and that customers are ranked by that revenue, providing context beyond the schema's field labels.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns top customers ranked by invoiced revenue over a date range. This is a specific verb+resource+scope, and it distinguishes itself from sibling tools like odoo_search_read (generic read) and odoo_sales_summary (summary, not customer-specific).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case (date-range revenue ranking) but does not explicitly state when to use it vs alternatives or when not to use it. There are no exclusion criteria or references to other tools in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0odoo_countodoo_fieldsodoo_list_modelsodoo_low_stockodoo_overdue_invoicesodoo_readodoo_sales_summaryodoo_search_readodoo_top_customersScored across 9 tools
Each tool has a distinct purpose: generic data access (search_read, read, count, fields, list_models) and specific business reports (overdue_invoices, sales_summary, low_stock, top_customers). No overlap between tools.
All tools follow the 'odoo_<action>' pattern in snake_case. Verbs are clear and consistent (search_read, read, count, list_models) and report names are descriptive nouns. No deviation.
With 9 tools, the set covers basic CRUD operations and several key business reports, which is reasonable for an Odoo MCP server. It is slightly on the lower side but not inadequate.
Significant gaps exist: no create, update, or delete operations for records. The server is largely read-only, which limits agents from performing many real-world tasks like updating invoices or creating sales orders.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
Let AI agents query data and act across all your business apps via MCP.
Odoo ERP for AI agents: hosted OAuth endpoint, gated writes, one endpoint for every instance.
Connect Exact Online to your AI assistant via MCP. Manage Exact Online with natural language.
