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

io.github.singleflo/odoo-assistant

by singleflo

Odoo Assistant MCP 서버

Model Context Protocol(MCP)을 통한 Odoo 가상 직원입니다. 이 서버는 Odoo의 비즈니스 로직, 레코드, 워크플로우를 LLM에 노출하여 안전하게 Odoo 데이터를 조회, 생성, 업데이트 및 작업할 수 있도록 합니다.

빠른 시작

1. 설치

서버를 직접 실행:

uvx odoo-assistant

또는 환경에 설치:

uv pip install odoo-assistant

개발을 위해 소스에서 설치하는 것도 가능합니다:

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

2. 환경 변수 구성

두 개의 변수가 필수이며, 나머지는 자동으로 발견되거나 기본값이 있습니다:

  • ODOO_BASE_URL: Odoo 인스턴스의 기본 URL (예: https://mycompany.odoo.com).

  • ODOO_API_KEY: Odoo API 키 (Odoo 14+, 설정 > 사용자 > API 키 > 새로 만들기에서 생성). 계정 비밀번호는 허용되지 않습니다: 키는 사용자별로, 범위가 지정되고 자체적으로 취소 가능합니다.

선택적 구성:

  • ODOO_DB: 데이터베이스 이름. 인스턴스가 정확히 하나의 데이터베이스를 제공할 때 자동으로 발견됨; 여러 개를 제공할 때 필요하며, 오류 메시지에 모든 이름이 표시됩니다.

  • ODOO_USER: 로그인. 키에서 발견되지만 최대 59회의 추가 왕복이 필요할 수 있음; 키 소유자의 uid가 60 이상이면 발견 실패. 설정하면 프로브를 절약합니다.

  • ODOO_MCP_MAX_LEVEL: 이 서버가 실행할 수 있는 최고 안전 수준, 0에서 4까지 (기본값: 3). 서버를 읽기 전용으로 만들거나 삭제를 허용하는 방법입니다 — 상한 선택 참조.

  • ODOO_MCP_PROTECTED_HOSTS: 이 서버가 쓰기를 거부하는 호스트 목록 (쉼표로 구분, 기본값은 비어 있음 — 패키지에 내장된 호스트 없음). 나열된 호스트는 여전히 읽기를 허용하며, 쓰기를 위해서는 의도적인 재정의로 ODOO_ALLOW_PROD_WRITE=yes가 필요합니다.

Related MCP server: mcp-server-odoo

안전 계층

모든 쓰기 및 작업은 Odoo에 도달하기 전에 동적 안전 분류기를 통과합니다. 작업은 L0에서 L5까지의 수준으로 분류됩니다:

수준

이름

설명

기본 상태

L0

L0_READ

읽기 전용 쿼리 (search_read, read, search_count).

허용

L1

L1_WRITE

단일 레코드 쓰기 및 생성.

허용

L2

L2_BATCH

여러 레코드에 영향을 미치는 배치 쓰기.

허용

L3

L3_STATE_CHANGE

워크플로우 상태 전환 (예: 주문 확인, 송장 게시).

허용

L4

L4_DESTRUCTIVE

파괴적 작업 (예: unlink, action_cancel, 보관).

차단

L5

L5_PRIVATE / L5_UNKNOWN

비공개 메서드 또는 알 수 없는 작업.

차단

상한 선택

ODOO_MCP_MAX_LEVEL은 이 서버가 실행할 수 있는 최고 수준을 설정합니다. 각 값은 누적됩니다 — 자신의 수준과 그 아래 모든 것을 허용합니다:

값

허용되는 작업

0

읽기 전용.

1

+ 단일 레코드 쓰기 및 생성.

2

+ 5개 초과 레코드의 배치.

3

기본값. + 주문 확인, 송장 게시, 메일 발송.

4

+ unlink, action_cancel, 보관.

5

허용되지만 효과는 4와 동일 — 아래 참조.

숫자를 선택하기 전에 알아야 할 두 가지 동작이 있습니다:

  • 5는 L5를 잠금 해제하지 않습니다. 두 L5 변형 모두 상한이 읽히기 전에 거부됩니다. L5_PRIVATE는 Odoo 자체가 _로 시작하는 모든 메서드를 거부하므로 어떤 상한도 제공할 수 없기 때문에 거부됩니다; L5_UNKNOWN은 분류되지 않은 메서드는 정의상 검토되지 않은 효과를 가지므로 거부됩니다. 이러한 메서드를 허용하는 방법은 safety_layer.py의 WRITE_L1/L3/L4에 추가하는 것입니다 — 코드에서 검토됨 — 결코 구성을 통해서가 아닙니다.

  • 잘못된 값은 시작을 거부합니다. ODOO_MCP_MAX_LEVEL="O"는 기본값으로 대체되지 않고 오류를 발생시킵니다. 기본값이 쓰기 가능하기 때문입니다: 오타로 인해 읽기 전용이라고 믿었던 서버가 쓰기 가능한 서버가 되어서는 안 됩니다.

상한은 사람이 대역 외에서 설정하며, 시작 시 프로세스 환경에서 읽힙니다. 이 서버에 대해 실행되는 모델은 이를 높일 수 없습니다; 호출이 상한을 초과하면 거부 메시지에 필요한 수준이 명시되므로, 에이전트는 작업이 무엇을 변경할지 설명하고 결정을 사용자에게 맡길 수 있습니다.

이는 이 서버의 권한이지 계정의 권한이 아닙니다. 셸 액세스 권한이 있는 에이전트는 Odoo를 직접 호출하여 MCP 서버를 우회할 수 있습니다. 클라이언트에 관계없이 유지되어야 하는 제한은 API 키가 속한 사용자의 Odoo 액세스 권한에 속하며, Odoo 서버가 이를 강제합니다.

Odoo 버전 지원

Odoo 14.0은 지원되는 최소 버전입니다. 이 서버는 API 키로만 인증하며, Odoo 13 이하에는 존재하지 않습니다.

Odoo 버전

API 키

XML-RPC

공식 유지 관리 (2026년 8월)

지원 수준 / 참고 사항

≤ 13.0

아니오

예

아니오

지원되지 않음. 이 서버로 인증할 수 없습니다.

14.0

예

예

아니오

프로토콜 호환. 실제 인스턴스에서 테스트되지 않음.

15.0

예

예

아니오

프로토콜 호환. 실제 인스턴스에서 테스트되지 않음.

16.0

예

예

아니오

프로토콜 호환. 실제 인스턴스에서 테스트되지 않음.

17.0

예

예

예 (2026년 9월까지)

프로토콜 호환. 실제 인스턴스에서 테스트되지 않음.

18.0

예

예

예 (2027년 9월까지)

주요 대상. 실제 인스턴스에서 검증 및 완전 지원.

19.0

예

예

예 (2028년 9월까지)

프로토콜 호환. 실제 인스턴스에서 테스트되지 않음. API 키에는 설명과 만료일(최대 3개월)이 필요합니다.

API 키 생성 경로

API 키를 생성하려면 Odoo 인스턴스에 로그인하고 다음으로 이동하세요: 환경 설정 / 내 프로필 → 계정 보안 → 새 API 키

전송 및 지원 중단 참고 사항

클라이언트는 기본 JSON-2 API가 /json/2/<model>/<method>에서 사용 가능한지 자동으로 감지하고(이 API는 Authorization: bearer <API_KEY>를 사용), 사용 불가능한 경우 XML-RPC로 대체합니다. XML-RPC 및 JSON-RPC는 Odoo 19에서 지원 중단되었으며 Odoo 22에서 제거될 예정입니다.

출처

도구 및 리소스

서버는 19개의 도구와 2개의 리소스 유형을 제공합니다:

도구

  1. search_read: 한 번의 호출로 레코드 검색 및 읽기 (Odoo search_read).

  2. read_record: ID로 하나의 레코드를 읽으며, 항상 명명된 필드를 사용합니다.

  3. count_records: 도메인과 일치하는 레코드 수 계산 (Odoo search_count).

  4. instance_overview: 연결된 인스턴스 요약: 버전, 회사, 영역별 볼륨, 사내 모듈, 이상 징후.

  5. required_fields: Odoo가 모델에 대해 create 전에 요구하는 사항, 적용할 기본값, 기존 레코드가 실제로 이를 사용하는 방법을 나열합니다.

  6. create_record: 레코드를 생성하며, unique_on이 주어지면 기존 일치 항목을 재사용합니다.

  7. write_record: 하나의 레코드에 필드 값을 쓰고 실제로 변경된 사항을 보고합니다.

  8. run_action: 워크플로우 메서드를 실행하고 남은 상태를 보고합니다.

  9. cancel_record: action_cancel을 통해 레코드를 취소하고, 반환된 마법사를 따릅니다.

  10. notify_user: 레코드의 채터에서 사용자에게 알림. 기본적으로 내부 알림입니다.

  11. create_activity: 활동 예약: 마감일이 있는 유일한 알림 유형입니다.

  12. download_docs: 레코드의 모든 문서를 디스크에 저장하며, 채터 파일도 포함됩니다.

  13. generate_pdf: 레코드의 PDF를 렌더링하고 저장된 위치를 반환합니다.

  14. list_message_targets: 메시지를 보낼 수 있는 사람과 위치를 나열 — 온라인/자리비움/오프라인 상태의 내부 사용자와 호출자의 열린 대화. 보내기 전에 먼저 물어보세요.

  15. read_conversation: Discuss 대화를 읽으며, 최신 항목이 먼저 옵니다.

  16. send_direct_message: 사용자의 채팅 시스템 트레이에 실시간으로 표시되는 1:1 Discuss 메시지를 보냅니다 — 이메일 없음, 알림 설정에 관계없이 도달합니다.

  17. send_channel_message: 기존 Discuss 채널에 게시하며, 비직원이 있는 방은 거부합니다.

  18. explore_module: 라이브 인스턴스를 조회하여 모듈의 구조를 발견합니다.

  19. list_known_modules: 이 서버가 학습한 모듈 목록: 이름, 생성 날짜, 레코드.

도구 10-11(notify_user, create_activity)은 레코드에 대해 알리고 받은 편지함 벨에 도착합니다; 도구 14-17은 채팅 시스템 트레이에 도착하는 Discuss 대화입니다. "사용자 X에게 메시지 보내기"는 두 번째 종류입니다 — notify_user가 아닌 send_direct_message입니다.

리소스

  • odoo://skill: Odoo 어시스턴트 스킬 지침에 액세스합니다.

  • odoo://ref/*: 탐색된 모듈에 대한 생성된 참조 문서에 액세스합니다.

호스트 구성 예제

아래의 모든 예제는 필수 사항만 포함합니다: 두 개의 필수 변수와 상한 — 서버가 쓸 수 있는지 여부를 결정하는 단일 설정으로, 사람이 소유한 파일에 표시됩니다. 데이터베이스와 로그인은 자동으로 발견되며, 3은 상한의 기본값입니다. 따옴표에 주의하세요: 환경 값은 문자열입니다.

Claude Desktop

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

.cursor/mcp.json에 추가하거나 Cursor 설정 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

VS Code settings.json에 다음을 추가하세요:

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

프로젝트의 opencode.json 또는 .opencode/opencode.json에 추가하거나, ~/.config/opencode/opencode.json에 추가하여 서버를 모든 곳에서 사용할 수 있게 하세요:

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

opencode의 형식은 위 호스트들과 여러 면에서 다릅니다: 키는 mcp (mcpServers 아님), type은 필수, command는 프로그램 과 그 인수를 포함하는 단일 배열 (args는 별도로 없음), 환경 블록은 environment (env 아님)입니다.

timeout을 의도적으로 설정하세요. 기본값은 5000ms이며, 세션의 첫 번째 호출은 인증 비용을 지불하고, instance_overview의 경우 수십 번의 XML-RPC 왕복이 발생합니다 — 실제 인스턴스에 대해 5초를 훨씬 넘깁니다.

opencode는 시작 시 한 번만 구성을 읽고 핫 리로드하지 않으므로, 편집 후 종료하고 다시 시작하세요. 여기서 변경하는 모든 사항(상한 포함)은 다음 실행 시에만 적용됩니다.

ChatGPT (Custom Connectors)

Custom Connectors를 통해 이 서버를 ChatGPT에 연결하려면:

  1. 설정 → 커넥터 → 커넥터 추가로 이동합니다.

  2. 서버 URL을 입력하거나 레지스트리에서 선택합니다.

  3. 메시지가 표시되면 Odoo 자격 증명을 입력합니다.

Hermes

Hermes CLI를 사용하여 서버를 추가합니다:

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

예제에서는 선택적 변수를 생략했습니다. 인스턴스가 여러 데이터베이스를 제공하는 경우 ODOO_DB를 설정하고, uid 프로브를 건너뛰려면 ODOO_USER를 설정하며, 기본값 3에서 상한을 변경하려면 ODOO_MCP_MAX_LEVEL을 설정합니다.

License

이 프로젝트는 MIT 라이선스에 따라 라이선스가 부여됩니다. 자세한 내용은 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