A build-to-order Odoo module that exposes your models and business actions to AI agents over the Model Context Protocol (MCP), with per-tool scoped permissions enforced by Odoo's own access rights and record rules. ECOSIRE scopes, builds, installs, and supports it for you. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $249.00 USD; request a quote for a scoped proposal.
Uygulama manifestosu
İş akışınıza göre tasarlandı
A build-to-order Odoo module that exposes your models and business actions to AI agents over the Model Context Protocol (MCP), with per-tool scoped permissions enforced by Odoo's own access rights and record rules. ECOSIRE scopes, builds, installs, and supports it for you.
Kendiniz kurmanıza gerek yok — ECOSIRE tarafından geliştirilen, kurulan ve desteklenen çalışır bir uygulama.
Tek seferlik geliştirme fiyatıyla başlayın. Kapsamı başlangıçta sizinle birlikte belirleriz.
ECOSIRE, Odoo ortamınızda geliştirir, yapılandırır ve kurar.
Yaklaşık 2–4 haftada yayına alırsınız; lansman sonrası bir destek süresi de dahildir.
Teams that run Odoo increasingly want an AI agent to read a customer's open orders, draft a quotation, check stock, or summarize a project — but wiring a general-purpose AI assistant into a live ERP safely is where the road runs out. Odoo already exposes everything over XML-RPC and JSON-RPC, but those APIs speak in raw model names, field lists, and integer IDs; they have no notion of "tools," no self-describing schema an agent can discover, and no natural way to say "this agent may read sale.order and create crm.lead, but may never touch account.move or delete anything." Hand an autonomous agent a full API key and you have handed it your whole database. Odoo core gives you the door but not the doorman.
We build a dedicated MCP Server module that turns your Odoo instance into a first-class, permission-scoped tool provider for AI agents. The module implements the Model Context Protocol handshake and exposes a curated catalog of tools — each one a controlled operation like search_partners, read_sale_order, create_lead, or run_report — declared with a JSON schema the agent can discover at connect time. Under the hood every tool is a thin, audited wrapper over the standard ORM (models.Model, search, read, create, write), never a raw SQL bypass. Crucially, each tool call executes as a specific Odoo user, so it inherits that user's ir.model.access.csv rights and every ir.rule record rule automatically: an agent scoped to a sales user physically cannot read accounting entries or another company's records, because Odoo's own security kernel refuses. We add a per-agent credential model, a configurable allow-list of tools, optional field-level masking, rate limits, and a full request/response audit log (mcp.call.log) with an accompanying QWeb report so you can see exactly what every agent did and when.
Technically the server ships as a proper module: an __manifest__.py declaring the dependency graph, new models for agent registrations and tool scopes with @api.depends computed status fields, security defined in ir.model.access.csv plus record rules that isolate agent credentials per company and per team, OWL/XML backend views for administrators to register agents and toggle tool scopes, and controller endpoints that terminate the MCP transport (HTTP with streaming, plus JSON-RPC fallback for constrained environments). Write-class tools can be gated behind an approval step routed through Odoo automated actions and activities, so a "create purchase order" call becomes a draft awaiting a human click rather than a silent commit. Everything is built and tested against Odoo 17.0, 18.0, and 19.0, and works on both Community and Enterprise — where Enterprise-only apps are in scope (for example Studio-generated models or specific accounting flows), we expose them through the same scoped tool layer.
Because this is a made-to-order build, nothing ships until we agree on scope. We start with a short scoping call to map which models, actions, and reports your agents actually need, which Odoo users they should impersonate, and where human approval gates belong; then we build your version, run UAT on a staging clone of your database, and deploy to production with a rollback plan. Typical delivery is 2 to 4 weeks from confirmed scope. Pricing starts from $249 (indicative, single-company base scope); the number of exposed tools, the depth of write/approval workflows, multi-company isolation, and integration with more than one AI agent platform increase the quoted scope. You receive a fixed quote after the scoping call — never a surprise invoice.
Runs day-to-day operations on Odoo and wants team members (or an internal assistant) to query orders, stock, and contacts through an AI agent — but needs hard guarantees that the agent cannot read finance data or delete records. Buys the scoped-permission model.
Owns Odoo access control and is nervous about exposing XML-RPC keys to an autonomous agent. Wants agent access enforced by the same `ir.model.access.csv` and record rules that govern human users, plus a full audit log — not a bolt-on that bypasses Odoo security.
Designing an agent-driven process (lead triage, quotation drafting, support summarization) and needs Odoo to expose clean, discoverable tools with schemas rather than raw model APIs, with write actions gated behind human approval.
Could build an MCP bridge themselves but wants a tested, multi-version, security-first foundation with a git handover to extend, instead of spending weeks on transport handling, scoping, and audit plumbing.
| Kriter | ECOSIRE | Özel Yapı | Rakip | Odoo Yerlisi |
|---|---|---|---|---|
| Permission scoping for AI agents | Per-tool allow-list enforced by ir.model.access + record rules | Whatever you build and remember to test | Often a single API key with broad access | |
| MCP protocol support | Full handshake + tool discovery with JSON schemas | You implement the transport yourself | Varies; may be generic or fixed toolset | |
| Audit trail of agent actions | Dedicated mcp.call.log model + QWeb report | Only if you build logging in | Usually minimal or absent | |
| Write / approval gating | Write tools optionally routed via automated actions + activities | Buildable but time-consuming | Rarely offered | |
| Odoo version & edition coverage | Built for 17/18/19, Community + Enterprise | Whatever you target and maintain | Often pinned to one version | |
| Fit to your models & workflows | Scoped to your exact tools and users | Fully bespoke, at your cost | Generic; you adapt to it | |
| Time and effort to production | 2–4 weeks, we build/UAT/deploy | Weeks to months of your team's time | Fast install, slow to secure properly | |
| Ownership & handover | Full git repo handover, yours to extend | You own it, and all its maintenance | Vendor-locked, closed source common |
This is a build-to-order module, so it is made for your instance rather than downloaded. Typical delivery is 2 to 4 weeks from confirmed scope. After the scoping call we agree the tool catalog and security rules, build your version, run UAT on a staging clone, and then deploy to production with a rollback plan. Tight, narrowly-scoped builds can land sooner; broad multi-company or multi-agent scopes sit at the longer end.
Pricing starts from $249 as an indicative, single-company base scope. The final number depends on how many tools you expose, the depth of write and approval workflows, multi-company isolation, and how many AI agent platforms you integrate. You get a fixed written quote after the scoping call — we never invoice against a moving target, and the from-price is a starting point, not a promise of the total.
Every tool call runs as a specific Odoo user you assign to the agent, so it inherits that user's `ir.model.access.csv` access rights and all `ir.rule` record rules. On top of that, the module enforces a per-agent tool allow-list, optional field masking, and rate limits. If a scoped user cannot see accounting or another company's records in the normal UI, the agent cannot see them either — the enforcement is Odoo's own security kernel, not a wrapper we invented.
Yes. We build and validate against Odoo 17.0, 18.0, and 19.0 on both Community and Enterprise. The core MCP transport, scoping, and audit logging are edition-independent because they sit on the standard ORM. Where your scope touches Enterprise-only apps, we expose those through the same scoped tool layer as part of the build.
Every build includes a post-go-live support window for bug fixes and adjustments within the delivered scope. Because you receive the full git repository, your own team can extend it freely. We also offer ongoing support and version-upgrade engagements (for example migrating your build to a newer Odoo major version) as a separate, scoped arrangement when you need it.
Yes, and that is the default posture. You can register an agent as fully read-only, expose write tools only on specific models, and route any write-class tool through an approval gate so it produces a draft plus an Odoo activity awaiting a human click rather than committing silently. Delete operations are opt-in and, in practice, we usually leave them off entirely.
The module includes per-agent rate limiting and concurrency caps specifically to protect production performance from runaway agent loops, and all reads go through the standard ORM with the same query patterns as the UI. We validate behavior under load during UAT on a staging clone before touching production, so you see the impact profile before go-live.

A build-to-order Odoo localization that loads Algeria's full wilaya and commune hierarchy with bilingual French and Arabic names, wired into partner addresses and reporting. ECOSIRE builds, installs, and supports it after your quotation.

A build-to-order 2Checkout (Verifone) payment integration for ERPNext, giving global digital-goods sellers card acceptance, 45+ local payment methods, multi-currency checkout, and reconciled invoices. ECOSIRE scopes, builds, installs, and supports it on your ERPNext v15/v16 instance.

A build-to-order 2Checkout / Verifone payment gateway for Magento 2 and Adobe Commerce: localized checkout in 12 languages, iDEAL, Giropay and regional methods, multi-currency global selling, subscription billing and tax/invoicing automation — engineered, installed and supported by ECOSIRE.
A build-to-order Odoo module that exposes your models and business actions to AI agents over the Model Context Protocol (MCP), with per-tool scoped permissions enforced by Odoo's own access rights and record rules. ECOSIRE scopes, builds, installs, and supports it for you.