# ZenBiz Multi-Client Docker MCP Platform

A Dockerized, multi-client version of the existing Odoo MCP connector. The codebase is shared, while every client runs in an isolated MCP container with its own configuration and Odoo credentials.

## Architecture

```text
                         HOST OPERATING SYSTEM

       clients/peltierpro/.env        clients/zenbiz/.env
                 |                           |
                 v                           v
       +--------------------+       +--------------------+
       | mcp-peltierpro     |       | mcp-zenbiz         |
       | container :8000    |       | container :8000    |
       | host      :8000    |       | host      :8001    |
       +---------+----------+       +----------+---------+
                 |                             |
                 v                             v
          Peltier Pro Odoo               ZenBiz Odoo

              same Docker image / same MCP tool modules
```

This directly follows the proposed initialization/configuration plan, but **does not introduce a database yet**. Configuration currently comes from per-client Docker environment files.

## Why this is multi-client

The application no longer hard-codes Peltier Pro in `server.py`. At container startup, `Settings.from_env()` initializes the MCP identity, Odoo connection, transport, OAuth and security settings from that client's `.env` file.

As a result, one repository can serve Peltier Pro, ZenBiz, and future customers without duplicating the tools.

## Project structure

```text
.
├── app/
│   ├── server.py              # generic MCP initialization
│   ├── config.py              # dynamic per-container settings
│   ├── odoo_client.py
│   ├── prompts.py
│   └── tools/                 # shared MCP capabilities
├── clients/
│   ├── peltierpro/
│   │   ├── .env               # local example; replace secrets
│   │   └── .env.example
│   ├── zenbiz/
│   │   ├── .env
│   │   └── .env.example
│   └── _template/
│       └── .env.example
├── Dockerfile                 # one reusable MCP image
└── docker-compose.yml         # creates multiple MCP containers
```

## Start both MCP containers

First replace `ODOO_API_KEY=replace-...` in the client `.env` files.

```bash
docker compose up -d --build
```

Then:

- Peltier Pro MCP: `http://localhost:8000/mcp`
- ZenBiz MCP: `http://localhost:8001/mcp`
- Peltier health: `http://localhost:8000/health`
- ZenBiz health: `http://localhost:8001/health`

Both containers listen on port `8000` internally. Docker maps them to different host ports, matching the proposed `MCP:8000`, `MCP:8001` model.

## Add a third client

Copy the template:

```bash
cp -R clients/_template clients/client3
cp clients/client3/.env.example clients/client3/.env
```

Add this service:

```yaml
mcp-client3:
  <<: *mcp-common
  container_name: mcp-client3
  env_file:
    - ./clients/client3/.env
  ports:
    - "8002:8000"
```

Then rebuild:

```bash
docker compose up -d --build
```

## Configuration flow

At this stage, the proposed **Initialization & Load Configurations** block is implemented by Docker + `Settings.from_env()`:

1. Docker Compose selects a client configuration.
2. Docker creates an isolated MCP container.
3. `app/config.py` loads client identity, Odoo settings, transport/security and OAuth settings.
4. `app/server.py` creates the MCP service and registers the shared tools.
5. The MCP container connects only to the Odoo instance defined for that client.

A future management system/database can replace or generate these `.env` files without requiring a redesign of the MCP tools.

## Security note

Do not commit real `.env` files or API keys. For production, use deployment secrets/environment variables (Railway, Docker secrets, a secrets manager, etc.).
# mcp-multiclient-platform