io.github.singleflo/odoo-assistant
Odoo Assistant MCP Server
Un empleado virtual de Odoo a través del Model Context Protocol (MCP). Este servidor expone la lógica de negocio, los registros y los flujos de trabajo de Odoo a los LLM, permitiéndoles consultar, crear, actualizar y actuar sobre los datos de Odoo de forma segura.
Inicio rápido
1. Instalación
Ejecute el servidor directamente:
uvx odoo-assistantO instálelo en su entorno:
uv pip install odoo-assistantLa instalación desde el código fuente para desarrollo sigue siendo posible:
uv pip install git+https://github.com/singleflo/odoo-assistant-mcp2. Configurar variables de entorno
Se requieren dos variables; todo lo demás se descubre o tiene un valor predeterminado:
ODOO_BASE_URL: La URL base de su instancia de Odoo (por ejemplo,https://mycompany.odoo.com).ODOO_API_KEY: La clave API de Odoo (Odoo 14+, generar en Ajustes > Usuarios > Claves API > Nueva). No se acepta una contraseña de cuenta: una clave es por usuario, con ámbito y revocable por sí misma.
Configuración opcional:
ODOO_DB: El nombre de la base de datos. Se descubre automáticamente cuando la instancia sirve exactamente una base de datos; se requiere cuando sirve varias — el error las nombra todas.ODOO_USER: El inicio de sesión. Se descubre a partir de la clave a costa de hasta 59 viajes de ida y vuelta adicionales; la detección falla si el uid del propietario de la clave es 60 o superior. Configurarlo ahorra la sonda.ODOO_MCP_MAX_LEVEL: El nivel de seguridad más alto que este servidor puede ejecutar, de0a4(predeterminado:3). Así es como hace que el servidor sea de solo lectura o le permite eliminar — consulte Elegir el límite máximo.ODOO_MCP_PROTECTED_HOSTS: Hosts separados por comas a los que este servidor se niega a escribir (vacío por defecto — ningún host está incluido en el paquete). Un host listado aún permite lecturas; escribir requiereODOO_ALLOW_PROD_WRITE=yescomo una anulación deliberada.
Related MCP server: mcp-server-odoo
Capa de seguridad
Cada escritura y acción pasa a través de un clasificador de seguridad dinámico antes de llegar a Odoo. Las operaciones se clasifican en niveles L0 a L5:
Nivel | Nombre | Descripción | Estado predeterminado |
L0 |
| Consultas de solo lectura ( | Permitido |
L1 |
| Escrituras y creaciones de un solo registro. | Permitido |
L2 |
| Escrituras por lotes que afectan a múltiples registros. | Permitido |
L3 |
| Transiciones de estado del flujo de trabajo (por ejemplo, confirmar pedidos, publicar facturas). | Permitido |
L4 |
| Operaciones destructivas (por ejemplo, | Bloqueado |
L5 |
| Métodos privados u operaciones desconocidas. | Bloqueado |
Elegir el límite máximo
ODOO_MCP_MAX_LEVEL establece el nivel más alto que este servidor puede ejecutar. Cada valor
es acumulativo: permite su propio nivel y todo lo inferior:
Valor | Lo que permite |
| Solo lectura. |
| + escrituras y creaciones de un solo registro. |
| + lotes de más de 5 registros. |
| Predeterminado. + confirmar pedidos, publicar facturas, enviar correo. |
| + |
| Aceptado, pero idéntico a |
Dos comportamientos son importantes de conocer antes de elegir un número:
5no desbloquea L5. Ambas variantes de L5 se rechazan antes de que se lea el límite máximo.L5_PRIVATEse rechaza porque Odoo mismo rechaza todo método que comience con_, por lo que ningún límite podría entregarlo;L5_UNKNOWNse rechaza porque un método que nadie clasificó tiene, por definición, efectos no revisados. La forma de permitir tal método es agregarlo aWRITE_L1/L3/L4ensafety_layer.py— en código, revisado — nunca a través de la configuración.Un valor inválido rechaza el inicio.
ODOO_MCP_MAX_LEVEL="O"genera una excepción en lugar de recurrir al valor predeterminado, porque el valor de respaldo es capaz de escribir: un error tipográfico no debe entregarle un servidor de escritura que creía que era de solo lectura.
El límite máximo se establece fuera de banda, por un humano, y se lee del entorno del proceso al inicio. El modelo que se ejecuta contra este servidor no puede elevarlo; cuando una llamada excede el límite máximo, la negativa nombra el nivel requerido, por lo que el agente puede explicar qué cambiaría la operación y dejar la decisión a usted.
Tenga en cuenta que esta es la autoridad de este servidor, no de la cuenta. Un agente con acceso a shell siempre puede eludir un servidor MCP invocando a Odoo directamente. Un límite que debe mantenerse independientemente del cliente pertenece a los derechos de acceso de Odoo del usuario al que pertenece la clave API, donde el servidor de Odoo lo aplica.
Soporte de versiones de Odoo
Odoo 14.0 es la versión mínima absoluta compatible porque este servidor se autentica solo mediante claves API, las cuales no existen en Odoo 13 o anterior.
Versión de Odoo | Claves API | XML-RPC | Mantenido oficialmente (Ago 2026) | Nivel de soporte / Notas |
≤ 13.0 | No | Sí | No | No compatible. No se puede autenticar con este servidor. |
14.0 | Sí | Sí | No | Compatible con el protocolo. No probado contra una instancia en vivo. |
15.0 | Sí | Sí | No | Compatible con el protocolo. No probado contra una instancia en vivo. |
16.0 | Sí | Sí | No | Compatible con el protocolo. No probado contra una instancia en vivo. |
17.0 | Sí | Sí | Sí (hasta sep 2026) | Compatible con el protocolo. No probado contra una instancia en vivo. |
18.0 | Sí | Sí | Sí (hasta sep 2027) | Objetivo principal. Verificado y totalmente compatible contra una instancia en vivo. |
19.0 | Sí | Sí | Sí (hasta sep 2028) | Compatible con el protocolo. No probado contra una instancia en vivo. Las claves API requieren descripción y caducidad (máx. 3 meses). |
Ruta de generación de clave API
Para generar una clave API, inicie sesión en su instancia de Odoo y navegue a: Preferencias / Mi perfil → Seguridad de la cuenta → Nueva clave API
Nota de transporte y desaprobación
El cliente detecta automáticamente si la API JSON-2 nativa está disponible en /json/2/<model>/<method> (que usa Authorization: bearer <API_KEY>) y recurre a XML-RPC si no lo está. Tenga en cuenta que XML-RPC y JSON-RPC están en desuso en Odoo 19 y se eliminarán en Odoo 22.
Fuentes
Documentación de la API externa de Odoo 14.0 (introducción a las claves API)
Documentación de la API RPC externa de Odoo 19.0 (desaprobación de XML-RPC)
Política de soporte estándar y extendido de Odoo (cronogramas de soporte)
Herramientas y recursos
El servidor expone 19 herramientas y 2 tipos de recursos:
Herramientas
search_read: Buscar y leer registros en una sola llamada (Odoosearch_read).read_record: Leer un registro por id, siempre con campos nombrados.count_records: Contar los registros que coinciden con un dominio (Odoosearch_count).instance_overview: Resumir la instancia conectada: versión, empresas, volúmenes por área, módulos internos, anomalías.required_fields: Listar lo que Odoo exige antes de uncreateen un modelo, el valor predeterminado que aplicaría y cómo los registros existentes lo usan realmente.create_record: Crear un registro, reutilizando una coincidencia existente cuando se proporcionaunique_on.write_record: Escribir valores de campo en un registro e informar qué cambió realmente.run_action: Ejecutar un método de flujo de trabajo e informar el estado que dejó.cancel_record: Cancelar un registro a través deaction_cancel, siguiendo el asistente que devuelve.notify_user: Notificar a los usuarios en el chatter de un registro. Interno por defecto.create_activity: Programar una actividad: la única notificación que lleva una fecha límite.download_docs: Guardar todos los documentos de un registro en disco, incluidos los archivos del chatter.generate_pdf: Renderizar el PDF de un registro y devolver dónde se guardó.list_message_targets: Listar quién puede recibir mensajes y dónde: usuarios internos con presencia (en línea/ausente/desconectado) y las conversaciones abiertas del llamante. Pregunte esto antes de enviar.read_conversation: Leer una conversación de Discuss, de la más nueva a la más antigua.send_direct_message: Enviar un mensaje 1-a-1 de Discuss que aparece en la bandeja de chat del usuario en tiempo real — sin correo electrónico, le llega independientemente de su configuración de notificaciones.send_channel_message: Publicar en un canal de Discuss existente, rechazando una sala que contenga a un no empleado.explore_module: Descubrir la estructura de un módulo interrogando la instancia en vivo.list_known_modules: Listar los módulos que este servidor ha aprendido: nombre, fecha de generación, registros.
Las herramientas 10-11 (notify_user, create_activity) notifican SOBRE un registro y aterrizan
en la campana de la bandeja de entrada; las herramientas 14-17 son conversaciones de Discuss que aterrizan en la bandeja
de chat. "Enviar mensaje al usuario X" es el segundo tipo — send_direct_message, no
notify_user.
Recursos
odoo://skill: Acceder a las instrucciones de habilidad del asistente de Odoo.odoo://ref/*: Acceder a la documentación de referencia generada para los módulos explorados.
Ejemplos de configuración de host
Cada ejemplo a continuación incluye solo lo que importa: las dos variables requeridas, y
el límite máximo — la única configuración que decide si este servidor puede escribir, hecha
visible en el archivo que posee el humano. La base de datos y el inicio de sesión se descubren,
y 3 es el valor predeterminado del límite máximo. Observe las comillas: los valores de entorno son
cadenas.
Claude Desktop
Agregue esto a su claude_desktop_config.json:
{
"mcpServers": {
"odoo-assistant": {
"command": "uvx",
"args": [
"odoo-assistant"
],
"env": {
"ODOO_BASE_URL": "https://mycompany.odoo.com",
"ODOO_API_KEY": "your-api-key-here",
"ODOO_MCP_MAX_LEVEL": "3"
}
}
}
}Cursor
Agregue esto a su .cursor/mcp.json o configúrelo en la interfaz de configuración de Cursor:
{
"mcpServers": {
"odoo-assistant": {
"command": "uvx",
"args": [
"odoo-assistant"
],
"env": {
"ODOO_BASE_URL": "https://mycompany.odoo.com",
"ODOO_API_KEY": "your-api-key-here",
"ODOO_MCP_MAX_LEVEL": "3"
}
}
}
}VS Code Copilot
Agregue esto a su settings.json de VS Code:
{
"mcp.servers": {
"odoo-assistant": {
"command": "uvx",
"args": [
"odoo-assistant"
],
"env": {
"ODOO_BASE_URL": "https://mycompany.odoo.com",
"ODOO_API_KEY": "your-api-key-here",
"ODOO_MCP_MAX_LEVEL": "3"
}
}
}
}opencode
Agregue esto a opencode.json o .opencode/opencode.json en su proyecto, o a
~/.config/opencode/opencode.json para que el servidor esté disponible en todas partes:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"odoo-assistant": {
"type": "local",
"enabled": true,
"command": [
"uvx",
"odoo-assistant"
],
"timeout": 120000,
"environment": {
"ODOO_BASE_URL": "https://mycompany.odoo.com",
"ODOO_API_KEY": "your-api-key-here",
"ODOO_MCP_MAX_LEVEL": "3"
}
}
}
}La forma de opencode difiere de los hosts anteriores en aspectos que rechaza directamente: la
clave es mcp (no mcpServers), type es obligatorio, command es un único array
que contiene el programa y sus argumentos (no hay args separado), y el bloque
de entorno es environment (no env).
Establezca timeout deliberadamente. Su valor predeterminado es 5000 ms, y la primera llamada de una
sesión paga la autenticación más, para instance_overview, docenas de viajes de ida y vuelta
XML-RPC — cómodamente más de cinco segundos contra una instancia real.
opencode lee su configuración una vez al inicio y no la recarga en caliente, por lo tanto, cierre y reinicie después de editarla. Cualquier cosa que cambie aquí — el límite máximo incluido — surte efecto solo en el próximo inicio.
ChatGPT (Conectores personalizados)
Para conectar este servidor a ChatGPT mediante Conectores personalizados:
Vaya a Configuración → Conectores → Agregar conector.
Ingrese la URL del servidor o seleccione del Registry.
Ingrese sus credenciales de Odoo cuando se le solicite.
Hermes
Agregue el servidor usando la CLI de Hermes:
hermes mcp add odoo-assistant \
--env ODOO_BASE_URL=https://mycompany.odoo.com \
--env ODOO_API_KEY=your-api-key-here \
--env ODOO_MCP_MAX_LEVEL=3 \
--args run odoo-assistantLos ejemplos omiten las variables opcionales. Establezca ODOO_DB cuando la instancia atienda varias bases de datos, ODOO_USER para omitir la sonda de uid, y ODOO_MCP_MAX_LEVEL para cambiar el límite máximo de su valor predeterminado de 3.
Licencia
Este proyecto está licenciado bajo la Licencia MIT. Consulte el archivo LICENSE para más detalles.
Available Tools
19 toolscancel_recordCDestructiveInspect
Cancel a record through action_cancel, following the wizard it returns.
Destructive, so the default ceiling refuses it and says what would not.
Inputs: model (required), record_id (required). Returns: result
count_recordsAInspect
Count the records matching a domain (Odoo search_count).
A count is only as honest as its domain:
account.move/account.move.linewithout amove_typefilter is refused — it would count invoices, bills, credit notes and journal entries together and match no figure the user has ever seen.A count answers "how many", never "how much". For an amount, read
amount_total_signed(company currency) and neveramount_total.On a multi-company instance the count differs per company: pass
company_idsor you are reporting one company as the whole business.
Args: model: Odoo model, e.g. "crm.lead". domain: Odoo domain. Omit to count everything the model holds. company_ids: Companies to count in, e.g. [1, 2].
Inputs: model (required), domain, company_ids. Returns: result
create_activityAInspect
Schedule an activity: the only notification that carries a deadline.
A chatter note is passive. An activity appears in the assignee's To-Do list and turns overdue when the date passes.
Args: model: the Odoo model, e.g. "crm.lead". record_id: id of the record the activity hangs off. summary: the one-line title the assignee will read. user_id: res.users id of the assignee. days: deadline offset from today, in days. activity_type: substring of an activity type name, e.g. "call". Activity types differ per instance; the first available type is used when this is omitted or matches nothing.
Inputs: model (required), summary (required), user_id (required), record_id (required), +2 more. Returns: result
create_recordAInspect
Create a record, reusing an existing match when unique_on is given.
unique_on is a list of FIELD NAMES taken from values (e.g.
["name", "email"]): they are searched first and the existing id comes
back instead of a duplicate. Odoo has no idempotency key, so a create that
is retried is simply a second record — this is the only protection there
is, and a cold-start run without it produced four identical customers.
Multi-company: put company_id in values. The context decides what is
visible, not which company owns the new record.
Inputs: model (required), values (required), unique_on. Returns: result
download_docsAInspect
Save every document of a record to disk — chatter files included.
Returns {"saved": [paths], "skipped": [[name, why]]}. skipped is not
noise: a database restored without its filestore keeps the attachment
rows and loses the bytes, and an empty result would read exactly like
"this record has no attachments".
Args: model: the Odoo model, e.g. "account.move". record_id: id of the record whose documents to fetch. dest_dir: directory to write the files into. Defaults to this platform's temporary directory — "/tmp" does not exist on Windows.
Inputs: model (required), record_id (required), dest_dir. Returns: result
explore_moduleBInspect
Discover a module's structure by interrogating the live instance.
Args:
module_name: Module to explore, e.g. "helpdesk". Must be a module
slug, since it names the reference file on "generate"; ignored
on "list".
action: "generate" (the default) writes the reference document,
"list" ranks what is worth exploring.
models: Comma-separated models for a module the script does not know,
e.g. "superchat.message,superchat.template". Defaults to the
script's own grouping for module_name.
Inputs: module_name (required), action, models. Returns: result
generate_pdfAInspect
Render the PDF of a record and return where it was saved.
An already rendered PDF is reused. Otherwise the model's own print/send
wizard produces it, and that wizard can also SEND the document — which is
why this is gated on action_send_and_print (L3_STATE_CHANGE) rather
than as a plain read.
Args: model: the Odoo model, e.g. "account.move". record_id: id of the record to print. dest_dir: directory to write the PDF into. Defaults to this platform's temporary directory — "/tmp" does not exist on Windows.
Inputs: model (required), record_id (required), dest_dir. Returns: result
instance_overviewAInspect
Summarise the connected instance: version, companies, volumes per area, in-house modules, anomalies.
The profile is built from the instance this server is CONNECTED to, and
cached per instance — census.profile_path() keys it on the live client,
not on an environment variable. That distinction is the whole point: with
two instances profiled on one machine, choosing by ODOO_DB (which is
discovered now, so often unset) once fell through to "the first file on
disk" and reported a neighbour's numbers as this instance's, with no error
and a perfectly plausible report.
First call against a new instance builds the profile, which costs a second
or so; every later call is free. Pass refresh=True after the instance has
changed — the report carries the timestamp it was taken.
When drilling into these figures, the two rules that keep them meaningful:
filter account.move by move_type, and sum amount_total_signed, never
amount_total.
Args: refresh: rebuild the profile from the instance instead of reusing it.
Inputs: refresh. Returns: result
list_known_modulesAInspect
List the modules this server has learned: name, generation date, records.
Inputs: no named parameters. Returns: result
list_message_targetsAInspect
Who can be messaged and where — ASK THIS BEFORE SENDING ANYTHING.
Two lists in one call, because an agent that cannot see the roster invents ids:
users: the internal, active users, each withim_status— 'online', 'away' (idle 30 minutes) or 'offline'. Presence is worth reading first: a Discuss message is delivered either way, but "offline" tells you nobody is going to answer right now.conversations: the ones the sender already belongs to and has not archived, withchannel_type— 'chat' is a 1-to-1, 'group' is a private multi-party, 'channel' is a room that may hold the whole company.membersandunreadare there so a broadcast is a deliberate choice rather than a surprise.
Use send_direct_message for a person and send_channel_message for a
conversation in this list. Neither of them is the tool for annotating an
invoice or an order — that is notify_user.
Inputs: no named parameters. Returns: result
notify_userAInspect
Write a note on a record's chatter and notify the users you name.
Both subtypes post a message that IS VISIBLE in the record's chatter. The difference is who it reaches beyond the people you name.
Args:
model: the Odoo model, e.g. "sale.order".
record_id: id of the record to write on.
message: the body. Send PLAIN TEXT: Odoo escapes anything that arrives
over RPC, so "x" is displayed as the literal characters
<b>x</b>, not as bold — there is no way to pass real markup
through this call, and newlines survive but are not turned into
line breaks. Write the note as prose.
user_ids: res.users ids to notify. They are notified each through
their OWN Odoo setting, inbox or email, so naming someone is not a
promise that no mail leaves.
subtype: where the message lands.
| subtype | visible in the chatter | emails a customer |
|-----------|------------------------|-------------------|
| "note" | yes, internal users | never |
| "inbox" | NO — notification only | never |
| "comment" | yes, everyone | **YES** |
"note" posts `mail.mt_note` and is the default: measured on a real
order it produced one inbox notification and zero emails.
"inbox" goes through `message_notify`, which Odoo documents as the
path for "messages that should not be displayed on a document" —
the person is notified, the record keeps no trace. "comment" posts
`mail.mt_comment` and is refused while an external follower
exists, unless force=True.
force: post the comment anyway, knowing those people get an email.
Inputs: model (required), message (required), user_ids (required), record_id (required), +2 more. Returns: result
read_conversationAInspect
Read what was said in a Discuss conversation, newest first.
This is how you answer "what did they write to me" or "what is going on in
that channel". list_message_targets gives you the channel_id and says
how many messages are unread.
Reading does not mark anything as read: the unread counter belongs to the member record and only the user's own client clears it.
Args:
channel_id: the Discuss channel, from list_message_targets.
limit: how many recent messages to return.
Inputs: channel_id (required), limit. Returns: result
read_recordAInspect
Read one record by id, always with named fields (writing.md pattern 12).
Omitting fields asks for a short list of state fields — never for all of
them: that read is slow at best and fails at worst.
account.move and account.move.line are refused here, because the
structural guard wants a move_type filter and this tool has nowhere to
put one. Use search_read with
[["id", "=", <id>], ["move_type", "=", "out_invoice"]] instead.
And never add up amount_total across records — it is in the record's own
currency. amount_total_signed is the company-currency twin to sum.
Args: model: Odoo model, e.g. "sale.order". record_id: The record's database id. fields: Field names to read. Omit for the usual state fields.
Inputs: model (required), record_id (required), fields. Returns: result
required_fieldsAInspect
List the fields Odoo demands before it will accept a create, with the
default it would apply and how existing records actually use it.
Ask this BEFORE create_record on a model you have not written to in this
session. The answer is read from the live instance — fields_get plus
default_get — never from a table in this file, so a model customised
in-house reports its own requirements.
The dangerous required field is the one that already carries a default: the
create succeeds without you naming it and the record lands wherever the
default points, with no error to notice. crm.lead.type is the standing
example — Odoo defaults it to 'lead', and on an instance that works its
pipeline as opportunities that record goes straight to a menu nobody opens.
That is why the live distribution is printed beside each default.
Args: model: Odoo model, e.g. "crm.lead".
Inputs: model (required). Returns: result
run_actionADestructiveInspect
Run a workflow method and report the state it left behind.
The level follows method: confirming or posting is a state change,
cancelling or unlinking is destructive and refused unless the server's
ceiling was raised deliberately.
Two behaviours come from the Writer and are worth knowing: a returned dict
carrying res_model is a wizard to follow rather than a result, and a
transition is one-way — calling it twice raises instead of doing nothing.
Inputs: model (required), method (required), record_ids (required). Returns: result
search_readAInspect
Search and read records in one call (Odoo search_read).
Two pitfalls this tool cannot fix for you:
account.moveandaccount.move.linemix customer invoices, vendor bills, credit notes and raw journal entries. A domain withoutmove_typeis refused — add["move_type", "=", "out_invoice"](orin_invoice,out_refund,in_refund) so the answer matches what the user sees on screen.NEVER sum
amount_total: it is expressed in each record's own currency, and eight foreign-currency invoices once inflated a total 11,9×. Ask foramount_total_signedinstead — any field with a_signedtwin is stored in company currency, and the twin is the one to add up.
Args: model: Odoo model, e.g. "sale.order". domain: Odoo domain, e.g. [["state", "=", "sale"]]. fields: Field names to return. Name them: the default asks for every field, which is slow and can fail to serialise on wide models. limit: Rows to return. Hard-capped at 200. offset: Rows to skip — how to page past a truncated result. company_ids: Companies to read from, e.g. [1, 2]. On a multi-company instance, omitting this reports one company as the whole business.
Inputs: model (required), domain (required), limit, fields, +2 more. Returns: result
send_channel_messageAInspect
Post to an EXISTING Discuss channel — everyone in it sees this.
The channel is never created here: list_message_targets shows the ones
that exist, and posting to a room of the wrong size is not recoverable by
deleting the message afterwards.
Members who are not employees of this instance — portal users, guests —
are named in a refusal rather than written to, the same rule notify_user
applies to external followers. Nothing is posted in that case.
Args:
channel_id: from list_message_targets.
message: the body, plain text or simple HTML.
Inputs: message (required), channel_id (required). Returns: result
send_direct_messageAInspect
Send a 1-to-1 Discuss message that appears in the user's chat systray.
This is the tool for "tell X", "message X", "warn X". It opens the private
chat with that user — reusing the existing one, channel_get matches on
the exact pair — and posts there. The bus pushes it in real time and it
persists, so a recipient who is offline finds it on their next login.
It reaches them whatever their notification setting says, and sends no
email at all. That is the difference from notify_user, which follows the
recipient's preference and lands in the Inbox bell instead.
Args:
user_id: res.users id of the recipient — from list_message_targets.
message: the body, plain text or simple HTML.
Inputs: message (required), user_id (required). Returns: result
write_recordADestructiveIdempotentInspect
Write field values to one record and report what actually changed.
Writing the value a record already holds succeeds and changes nothing; only the before/after comparison tells that apart from a real update, so that comparison is the answer.
Setting active to False archives the record — the same visible outcome as
deleting it — and is classified destructive rather than as a plain write.
Inputs: model (required), values (required), record_id (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Each tool targets a distinct Odoo operation: reading, searching, counting, creating, writing, workflow actions, messaging, module exploration, etc. While messaging has multiple tools (notify_user, send_direct_message, send_channel_message), their descriptions clearly differentiate by context (record chatter, 1-to-1 chat, channel). No overlapping purposes remain ambiguous.
All tools follow a consistent verb_noun pattern in snake_case (e.g., search_read, create_record, list_message_targets). The naming is predictable and intuitive, with verbs like read, create, write, send, list, and explore clearly indicating the action.
With 19 tools, the server covers a broad set of Odoo capabilities (CRUD, workflow, messaging, file handling, module introspection). While slightly above the typical 3-15 recommended range, the count is justified by the complexity of the ERP domain and each tool serves a distinct purpose without redundancy.
The tool surface covers essential CRUD operations, workflow actions, messaging, document handling, and instance/ module exploration. However, there is no dedicated delete tool (only cancel for specific workflows) and no bulk update or file upload tool. These minor gaps are workable but prevent full lifecycle coverage.
Maintenance
Related MCP Connectors
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Odoo MCP connector for ChatGPT and Claude: ask sales, invoices and stock in plain words. Read-only.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Related MCP Servers
- AlicenseBqualityNot gradedmaintenanceAn MCP server that enables AI assistants to interact with Odoo ERP apps like Inventory, CRM, Sales, and Manufacturing. It allows users to read, create, and manage Odoo records and workflows using natural language commands.251MIT
- AlicenseNot gradedqualityDmaintenanceAn extensible MCP server that integrates Odoo with LLMs to enable querying and managing business data like partners, quotations, and sales orders. It supports custom tool registration and multiple transport protocols for both local and remote communication.2MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that connects AI assistants to Odoo ERP instances via the built-in XML-RPC API without requiring any additional addons. It enables users to search, create, update, and manage Odoo records and models through natural language.MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI assistants to interact with Odoo ERP, allowing natural language queries, record creation, updates, and deletions.LGPL 3.0