Skip to main content
Glama
io.github.singleflo/odoo-assistant

io.github.singleflo/odoo-assistant

by singleflo

Odoo Assistant MCP Server

Ein virtueller Odoo-Mitarbeiter über das Model Context Protocol (MCP). Dieser Server gibt Odoos Geschäftslogik, Datensätze und Workflows für LLMs frei, sodass diese sicher Odoo-Daten abfragen, erstellen, aktualisieren und bearbeiten können.

Schnellstart

1. Installieren

Führen Sie den Server direkt aus:

uvx odoo-assistant

Oder installieren Sie ihn in Ihrer Umgebung:

uv pip install odoo-assistant

Die Installation aus dem Quellcode für die Entwicklung bleibt möglich:

uv pip install git+https://github.com/singleflo/odoo-assistant-mcp

2. Umgebungsvariablen konfigurieren

Zwei Variablen sind erforderlich; alles andere wird automatisch ermittelt oder hat einen Standardwert:

  • ODOO_BASE_URL: Die Basis-URL Ihrer Odoo-Instanz (z. B. https://mycompany.odoo.com).

  • ODOO_API_KEY: Der Odoo-API-Schlüssel (Odoo 14+, erstellen unter Einstellungen > Benutzer > API-Schlüssel > Neu). Ein Kontopasswort wird nicht akzeptiert: Ein Schlüssel ist pro Benutzer, begrenzt und eigenständig widerrufbar.

Optionale Konfiguration:

  • ODOO_DB: Der Datenbankname. Wird automatisch ermittelt, wenn die Instanz genau eine Datenbank bedient; erforderlich, wenn mehrere vorhanden sind – der Fehler listet alle auf.

  • ODOO_USER: Der Login. Wird aus dem Schlüssel ermittelt, was bis zu 59 zusätzliche Roundtrips kosten kann; die Erkennung schlägt fehl, wenn die uid des Schlüsselbesitzers 60 oder höher ist. Das Setzen vermeidet diese Abfrage.

  • ODOO_MCP_MAX_LEVEL: Die höchste Sicherheitsstufe, die dieser Server ausführen darf, 0 bis 4 (Standard: 3). Damit machen Sie den Server schreibgeschützt oder erlauben das Löschen – siehe Die Obergrenze wählen.

  • ODOO_MCP_PROTECTED_HOSTS: Kommagetrennte Hosts, für die dieser Server Schreibvorgänge ablehnt (standardmäßig leer – kein Host ist im Paket fest integriert). Ein gelisteter Host erlaubt weiterhin Lesezugriffe; zum Schreiben muss ODOO_ALLOW_PROD_WRITE=yes als bewusste Überschreibung gesetzt werden.

Related MCP server: mcp-server-odoo

Sicherheitsebene

Jeder Schreibvorgang und jede Aktion durchläuft vor der Ausführung an Odoo einen dynamischen Sicherheitsklassifizierer. Operationen werden in die Stufen L0 bis L5 eingeteilt:

Stufe

Name

Beschreibung

Standardstatus

L0

L0_READ

Nur-Lese-Abfragen (search_read, read, search_count).

Erlaubt

L1

L1_WRITE

Schreibvorgänge und Erstellungen einzelner Datensätze.

Erlaubt

L2

L2_BATCH

Batch-Schreibvorgänge, die mehrere Datensätze betreffen.

Erlaubt

L3

L3_STATE_CHANGE

Workflow-Statusübergänge (z. B. Aufträge bestätigen, Rechnungen buchen).

Erlaubt

L4

L4_DESTRUCTIVE

Destruktive Operationen (z. B. unlink, action_cancel, Archivieren).

Blockiert

L5

L5_PRIVATE / L5_UNKNOWN

Private Methoden oder unbekannte Operationen.

Blockiert

Die Obergrenze wählen

ODOO_MCP_MAX_LEVEL legt die höchste Stufe fest, die dieser Server ausführen darf. Jeder Wert ist kumulativ – er erlaubt seine eigene Stufe und alles darunter:

Wert

Was erlaubt wird

0

Nur Lesezugriffe.

1

+ Schreibvorgänge und Erstellungen einzelner Datensätze.

2

+ Batches mit mehr als 5 Datensätzen.

3

Standard. + Bestätigen von Aufträgen, Buchen von Rechnungen, Senden von E-Mails.

4

+ unlink, action_cancel, Archivieren.

5

Wird akzeptiert, aber effektiv identisch zu 4 – siehe unten.

Zwei Verhaltensweisen sollten Sie kennen, bevor Sie eine Zahl wählen:

  • 5 schaltet L5 nicht frei. Beide L5-Varianten werden abgelehnt, bevor die Obergrenze überhaupt gelesen wird. L5_PRIVATE wird abgelehnt, weil Odoo selbst jede Methode ablehnt, die mit _ beginnt, sodass keine Obergrenze sie bereitstellen könnte; L5_UNKNOWN wird abgelehnt, weil eine Methode, die niemand klassifiziert hat, definitionsgemäß ungeprüfte Auswirkungen hat. Der Weg, eine solche Methode zu erlauben, besteht darin, sie in WRITE_L1/L3/L4 in safety_layer.py hinzuzufügen – im Code, überprüft – niemals durch Konfiguration.

  • Ein ungültiger Wert verhindert den Start. ODOO_MCP_MAX_LEVEL="O" führt zu einem Fehler, anstatt auf den Standardwert zurückzufallen, weil der Standardwert schreibfähig ist: Ein Tippfehler darf Ihnen keinen schreibenden Server bescheren, den Sie für schreibgeschützt hielten.

Die Obergrenze wird out-of-band von einem Menschen gesetzt und beim Start aus der Prozessumgebung gelesen. Das gegen diesen Server laufende Modell kann sie nicht erhöhen; wenn ein Aufruf die Obergrenze überschreitet, nennt die Ablehnung die erforderliche Stufe, sodass der Agent erklären kann, was die Operation ändern würde, und die Entscheidung Ihnen überlässt.

Beachten Sie, dass dies die Autorität dieses Servers ist, nicht die des Kontos. Ein Agent mit Shell-Zugriff kann einen MCP-Server jederzeit umgehen, indem er Odoo direkt aufruft. Eine Einschränkung, die unabhängig vom Client gelten muss, gehört in die Odoo-Zugriffsrechte des Benutzers, dem der API-Schlüssel gehört, wo der Odoo-Server sie durchsetzt.

Odoo-Versionsunterstützung

Odoo 14.0 ist die absolute Mindestversion, die unterstützt wird, da dieser Server nur mit API-Schlüsseln authentifiziert, die es in Odoo 13 oder älter nicht gibt.

Odoo-Version

API-Schlüssel

XML-RPC

Offiziell gewartet (Aug. 2026)

Support-Level / Hinweise

≤ 13.0

Nein

Ja

Nein

Nicht unterstützt. Kann mit diesem Server nicht authentifizieren.

14.0

Ja

Ja

Nein

Protokollkompatibel. Nicht an einer Live-Instanz getestet.

15.0

Ja

Ja

Nein

Protokollkompatibel. Nicht an einer Live-Instanz getestet.

16.0

Ja

Ja

Nein

Protokollkompatibel. Nicht an einer Live-Instanz getestet.

17.0

Ja

Ja

Ja (bis Sep. 2026)

Protokollkompatibel. Nicht an einer Live-Instanz getestet.

18.0

Ja

Ja

Ja (bis Sep. 2027)

Primäres Ziel. Verifiziert und vollständig unterstützt an einer Live-Instanz.

19.0

Ja

Ja

Ja (bis Sep. 2028)

Protokollkompatibel. Nicht an einer Live-Instanz getestet. API-Schlüssel erfordern Beschreibung und Ablauf (max. 3 Monate).

Pfad zur API-Schlüsselgenerierung

Um einen API-Schlüssel zu generieren, melden Sie sich bei Ihrer Odoo-Instanz an und navigieren Sie zu: Einstellungen / Mein Profil → Kontosicherheit → Neuer API-Schlüssel

Transport- und Deprecation-Hinweis

Der Client erkennt automatisch, ob die native JSON-2-API unter /json/2/<model>/<method> verfügbar ist (die Authorization: bearer <API_KEY> verwendet) und fällt auf XML-RPC zurück, wenn nicht. Bitte beachten Sie, dass XML-RPC und JSON-RPC in Odoo 19 veraltet sind und für Odoo 22 zur Entfernung vorgesehen sind.

Quellen

Tools und Ressourcen

Der Server stellt 19 Tools und 2 Ressourcentypen bereit:

Tools

  1. search_read: Datensätze in einem Aufruf suchen und lesen (Odoo search_read).

  2. read_record: Einen Datensatz nach ID lesen, immer mit benannten Feldern.

  3. count_records: Die Anzahl der Datensätze zählen, die einer Domain entsprechen (Odoo search_count).

  4. instance_overview: Die verbundene Instanz zusammenfassen: Version, Unternehmen, Volumen pro Bereich, hauseigene Module, Anomalien.

  5. required_fields: Auflisten, was Odoo vor einem create auf einem Modell verlangt, den Standardwert, den es anwenden würde, und wie vorhandene Datensätze es tatsächlich nutzen.

  6. create_record: Einen Datensatz erstellen, wobei ein vorhandener Treffer wiederverwendet wird, wenn unique_on angegeben ist.

  7. write_record: Feldwerte in einen Datensatz schreiben und melden, was sich tatsächlich geändert hat.

  8. run_action: Eine Workflow-Methode ausführen und den zurückgelassenen Status melden.

  9. cancel_record: Einen Datensatz über action_cancel stornieren, dem zurückgegebenen Assistenten folgend.

  10. notify_user: Benutzer im Chatter eines Datensatzes benachrichtigen. Standardmäßig intern.

  11. create_activity: Eine Aktivität planen: die einzige Benachrichtigung, die eine Frist trägt.

  12. download_docs: Alle Dokumente eines Datensatzes auf die Festplatte speichern, einschließlich Chatter-Dateien.

  13. generate_pdf: Das PDF eines Datensatzes rendern und zurückgeben, wo es gespeichert wurde.

  14. list_message_targets: Auflisten, wer benachrichtigt werden kann und wo – interne Benutzer mit Anwesenheit (online/abwesend/offline) und die offenen Konversationen des Aufrufers. Vor dem Senden abfragen.

  15. read_conversation: Eine Discuss-Konversation lesen, neueste zuerst.

  16. send_direct_message: Eine 1-zu-1-Discuss-Nachricht senden, die in Echtzeit in der Chat-Systray des Benutzers erscheint – keine E-Mail, erreicht ihn unabhängig von seiner Benachrichtigungseinstellung.

  17. send_channel_message: In einem vorhandenen Discuss-Kanal posten, wobei ein Raum abgelehnt wird, der einen Nicht-Mitarbeiter enthält.

  18. explore_module: Die Struktur eines Moduls durch Abfragen der Live-Instanz erkunden.

  19. list_known_modules: Die Module auflisten, die dieser Server gelernt hat: Name, Erstellungsdatum, Datensätze.

Die Tools 10-11 (notify_user, create_activity) benachrichtigen ÜBER einen Datensatz und landen in der Inbox-Glocke; die Tools 14-17 sind Discuss-Konversationen, die in der Chat-Systray landen. "Nachricht an Benutzer X" ist die zweite Art – send_direct_message, nicht notify_user.

Ressourcen

  • odoo://skill: Zugriff auf die Odoo-Assistant-Fähigkeitsanweisungen.

  • odoo://ref/*: Zugriff auf generierte Referenzdokumentation für erkundete Module.

Host-Konfigurationsbeispiele

Jedes Beisiel unten enhält nur das Wesentliche: die beien erfordelichen Variablen und die Oberrenze – die eine Einstellung, die entsheiedet, ob dieser Server schreiben darf, sichtbar in der Datei, die der Mensch besitzt. Die Datenbank und der Login werden ermittelt, und 3 ist der Standard der Oberrenze. Beachten Sie die Anführungszeichen: Umgebungswerte sind Zeichenketten.

Claude Desktop

Fügen Sie dies zu Ihrer claude_desktop_config.json hinzu:

{
  "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

Fügen Sie dies zu Ihrer .cursor/mcp.json hinzu oder konfigurieren Sie es in der Cursor-Einstellungs-UI:

{
  "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

Fügen Sie dies zu Ihrer VS-Code-settings.json hinzu:

{
  "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

Fügen Sie dies zu opencode.json oder .opencode/opencode.json in Ihrem Projekt hinzu oder zu ~/.config/opencode/opencode.json, um den Server überall verfügbar zu machen:

{
  "$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"
      }
    }
  }
}

Die Struktur von opencode unterscheidet sich von den oben genannten Hosts auf eine Weise, die diese direkt ablehnen: Der Schlüssel ist mcp (nicht mcpServers), type ist erforderlich, command ist ein einzelnes Array, das das Programm und seine Argumente enthält (es gibt kein separates args), und der Umgebungsblock ist environment (nicht env).

Setzen Sie timeout bewusst. Der Standardwert beträgt 5000 ms, und der erste Aufruf einer Sitzung umfasst die Authentifizierung sowie für instance_overview Dutzende von XML-RPC-Roundtrips – bequem über fünf Sekunden gegen eine echte Instanz.

opencode liest seine Konfiguration einmal beim Start und lädt sie nicht neu, also beenden und neu starten nach der Bearbeitung. Alles, was Sie hier ändern – einschließlich der Obergrenze – wirt erst beim nächsten Staret wirksam.

ChatGPT (Benutzerdefinierte Konnektoren)

Um diesen Server über benutzerdefinierte Konnektoren mit ChatGPT zu verbinden:

  1. Gehen Sie zu Einstellungen → Konnektoren → Konnektor hinzufügen.

  2. Geben Sie die Server-URL ein oder wählen Sie aus dem Registry.

  3. Geben Sie bei Aufforderung Ihre Odoo-Anmeldedaten ein.

Hermes

Fügen Sie den Server über die Hermes CLI hinzu:

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-assistant

Die Beispiele lassen die optionalen Variablen aus. Setzen Sie ODOO_DB, wenn die Instanz mehrere Datenbanken bedient, ODOO_USER, um die uid-Abfrage zu überspringen, und ODOO_MCP_MAX_LEVEL, um die Obergrenze gegenüber dem Standardwert von 3 zu ändern.

License

Dieses Projekt ist unter der MIT-Lizenz lizenziert. Weitere Informationen finden Sie in der Datei LICENSE.

Available Tools

19 tools
cancel_recordC
Destructive
Inspect

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.line without a move_type filter 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 never amount_total.

  • On a multi-company instance the count differs per company: pass company_ids or 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 with im_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, with channel_type — 'chat' is a 1-to-1, 'group' is a private multi-party, 'channel' is a room that may hold the whole company. members and unread are 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_actionA
Destructive
Inspect

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.move and account.move.line mix customer invoices, vendor bills, credit notes and raw journal entries. A domain without move_type is refused — add ["move_type", "=", "out_invoice"] (or in_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 for amount_total_signed instead — any field with a _signed twin 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_recordA
DestructiveIdempotent
Inspect

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

    A3.7/5.0

    Scored across 19 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count4/5

    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.

    Completeness4/5

    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

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      Not graded
      maintenance
      An 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.
      25
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An 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.
      2
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An 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
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that enables AI assistants to interact with Odoo ERP, allowing natural language queries, record creation, updates, and deletions.
      LGPL 3.0