iflow-mcp_vzeman-odoo-mcp-server 0.2.0__py3-none-any.whl

iflow_mcp_vzeman_odoo_mcp_server-0.2.0.dist-info/METADATA

@@ -0,0 +1,1044 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_vzeman-odoo-mcp-server
+Version: 0.2.0
+Summary: Hybrid MCP server for Odoo ERP integration - supports both HTTP streaming and stdio modes for AI assistants
+Project-URL: Homepage, https://github.com/vzeman/odoo-mcp-server
+Project-URL: Bug Tracker, https://github.com/vzeman/odoo-mcp-server/issues
+Project-URL: Documentation, https://github.com/vzeman/odoo-mcp-server#readme
+Author-email: Viktor Zeman <vzeman@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai,api-sports-pattern,assistant,erp,integration,mcp,odoo
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.104.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: mcp==1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: python-multipart>=0.0.6
+Requires-Dist: sse-starlette>=1.6.0
+Requires-Dist: uvicorn[standard]>=0.24.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Odoo MCP Server (Hybrid)
+
+A hybrid Model Context Protocol (MCP) server that enables AI assistants to interact with Odoo ERP systems. Supports both **HTTP streaming** (for web AI agents) and **stdio** (for local AI assistants) modes.
+
+## 📺 Demo
+
+### stdio Mode Demo (Claude Desktop)
+![stdio Mode Demo](docs/images/demo.gif)
+
+### HTTP Mode Demo (AI Agents & Remote Access)
+![HTTP Mode Demo](docs/images/odoo-demo.gif)
+
+### Example Output
+
+![Output Example](docs/images/output-example.png)
+
+## 🚀 Quick Start
+
+### HTTP Mode (AI Agents & Remote Access)
+
+```bash
+# Clone the repository
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+
+# Copy example and configure
+cp docker-compose.example.yml docker-compose.yml
+# Edit docker-compose.yml with your Odoo credentials
+
+# Start with Docker Compose
+docker-compose up -d
+
+# Access the server
+curl http://localhost:8000/health
+```
+
+### stdio Mode (Claude Desktop)
+
+#### Option 1: Install from PyPI (recommended)
+
+```bash
+# Install
+pip install odoo-mcp-server
+```
+
+#### Option 2: Install from source
+
+```bash
+# Clone the repository
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+
+# Install in development mode
+pip install -e .
+```
+
+#### Configure Claude Desktop
+
+Add to your Claude Desktop config file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Windows**: `%APPDATA%/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "odoo": {
+      "command": "python",
+      "args": ["-m", "mcp_server_odoo"],
+      "env": {
+        "ODOO_URL": "https://your-instance.odoo.com",
+        "ODOO_DB": "your-database",
+        "ODOO_USERNAME": "your-email@example.com",
+        "ODOO_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+
+# Install dependencies
+pip install -e .
+
+# Set environment variables
+export ODOO_URL="https://your-instance.odoo.com"
+export ODOO_DB="your-database"
+export ODOO_USERNAME="your-email@example.com"
+export ODOO_API_KEY="your-api-key"
+
+# Run the HTTP server
+python -m mcp_server_odoo.http_server
+
+# Run the stdio server
+python -m mcp_server_odoo
+```
+
+## 🌐 Remote Access with ngrok (AI Agent Integration)
+
+This implementation allows you to expose your local MCP server to AI agents like Flowhunt, enabling remote automation of your Odoo business processes.
+
+### Why Use ngrok?
+
+- **Remote AI Access**: AI agents can connect to your MCP server from anywhere
+- **Business Automation**: Enable Flowhunt and other AI platforms to automate your Odoo workflows
+- **Secure Tunneling**: ngrok provides secure HTTPS tunnels with authentication
+- **No Infrastructure**: No need to deploy to cloud servers
+
+### Setup Instructions
+
+#### 1. Install ngrok
+
+**Download and Install:**
+```bash
+# macOS (using Homebrew)
+brew install ngrok
+
+# Or download directly from https://ngrok.com/download
+```
+
+**Sign up and get your authtoken:**
+1. Go to [ngrok.com](https://ngrok.com) and create a free account
+2. Get your authtoken from the dashboard
+3. Configure ngrok:
+```bash
+ngrok config add-authtoken YOUR_AUTHTOKEN_HERE
+```
+
+#### 2. Start Your MCP Server
+
+```bash
+# Start the MCP server with Docker
+docker-compose up -d
+
+# Verify it's running locally
+curl http://localhost:8000/health
+```
+
+#### 3. Create ngrok Tunnel
+
+```bash
+# Create a public tunnel to your local MCP server
+ngrok http http://localhost:8080
+
+# You'll see output like:
+# Session Status                online
+# Account                       your-email@example.com
+# Version                       3.x.x
+# Region                        United States (us)
+# Latency                       -
+# Web Interface                 http://127.0.0.1:4040
+# Forwarding                    https://abc123.ngrok-free.app -> http://localhost:8000
+```
+
+**Copy the HTTPS URL** (e.g., `https://abc123.ngrok-free.app`) - this is your public MCP server endpoint.
+
+#### 4. Configure Flowhunt Integration
+
+**Flowhunt Implementation Process:**
+
+Create a custom flow with AI Agents:
+
+1. **Create a New Flow:**
+   - Go to Flowhunt Dashboard
+   - Click "Create New Flow"
+   - Give your flow a name (e.g., "Odoo Business Automation")
+
+2. **Add AI Agent Component:**
+   - Drag and drop an "AI Agent" component into your flow
+   - Connect the AI Agent to:
+     - **Input**: Data source or trigger
+     - **Output**: Next step in your workflow
+     - **Chat History**: For context and conversation memory
+     - **MCP Server**: Your Odoo MCP server
+
+3. **Configure MCP Server Connection:**
+   - In the AI Agent settings, go to "MCP Server Configuration"
+   - **Server URL**: `https://abc123.ngrok-free.app`
+   - **Protocol**: HTTP/HTTPS
+   - **Authentication**: None (or configure as needed)
+   - Save the configuration
+
+4. **Test the Connection:**
+   - In your Flowhunt flow, start a chat with the AI Agent
+   - Ask the AI to test the Odoo connection, for example:
+     ```
+     "Can you list all available Odoo models?"
+     "Show me the first 5 customers in the system"
+     "What tools are available for Odoo operations?"
+     ```
+   - The AI should be able to access your Odoo data through the MCP server
+
+#### 5. Flowhunt Workflow Examples
+
+**Complete Flow Setup Process:**
+
+1. **Customer Follow-up Flow:**
+   ```
+   Trigger: Daily schedule or webhook
+   ↓
+   AI Agent: "Find customers who haven't purchased in 6 months"
+   ↓ (uses MCP: search_records)
+   AI Agent: "Create follow-up tasks for each customer"
+   ↓ (uses MCP: create_record)
+   Output: Email report or Slack notification
+   ```
+
+2. **Sales Order Automation:**
+   ```
+   Trigger: New lead qualification webhook
+   ↓
+   AI Agent: "Check if lead is qualified and ready for sales order"
+   ↓ (uses MCP: search_records, get_record)
+   AI Agent: "Create sales order with appropriate products"
+   ↓ (uses MCP: create_record)
+   Output: Sales order confirmation email
+   ```
+
+3. **Inventory Management Flow:**
+   ```
+   Trigger: Hourly schedule
+   ↓
+   AI Agent: "Check all products for low stock levels"
+   ↓ (uses MCP: search_records)
+   AI Agent: "Create purchase orders for items below reorder point"
+   ↓ (uses MCP: create_record)
+   Output: Purchase order notifications to procurement team
+   ```
+
+**AI Agent Prompts for Odoo Operations:**
+
+```bash
+# Customer Management
+"Search for all customers in California with more than $10,000 in total sales"
+
+# Sales Operations
+"Create a new sales order for customer ID 42 with 5 units of product ID 123"
+
+# Inventory Tracking
+"Find all products with stock quantity below 10 and create purchase orders"
+
+# Financial Reporting
+"Generate a report of all unpaid invoices from the last 30 days"
+```
+
+### Advanced ngrok Configuration
+
+#### Custom Subdomain (Paid Plan)
+```bash
+# Use a custom subdomain for consistent URLs
+ngrok http 8000 --subdomain=my-odoo-mcp
+# Results in: https://my-odoo-mcp.ngrok.io
+```
+
+#### Authentication & Security
+```bash
+# Add basic authentication
+ngrok http 8000 --basic-auth="username:password"
+
+# Add custom headers
+ngrok http 8000 --request-header-add="X-Custom-Header: value"
+```
+
+#### Multiple Tunnels
+```bash
+# Create multiple tunnels for different services
+ngrok http 8000 --subdomain=odoo-mcp
+ngrok http 3000 --subdomain=odoo-web
+```
+
+### Production Considerations
+
+#### 1. Persistent Tunnels
+For production use, consider:
+- **ngrok Pro/Enterprise**: For persistent URLs and custom domains
+- **Self-hosted ngrok**: For complete control
+- **Alternative solutions**: Cloudflare Tunnel, localtunnel, etc.
+
+#### 2. Security Best Practices
+```bash
+# Use authentication
+ngrok http 8000 --basic-auth="admin:secure-password"
+
+# Restrict to specific IPs (if using ngrok Pro)
+ngrok http 8000 --allow-cidr="192.168.1.0/24"
+
+# Use custom domains with SSL
+ngrok http 8000 --hostname=your-domain.com
+```
+
+#### 3. Monitoring & Logs
+```bash
+# View ngrok web interface
+# Open http://127.0.0.1:4040 in your browser
+
+# Monitor requests and responses
+# Check MCP server logs
+docker-compose logs -f mcp-server
+```
+
+### Troubleshooting
+
+#### Common Issues
+
+**1. ngrok Tunnel Not Working:**
+```bash
+# Check if ngrok is authenticated
+ngrok config check
+
+# Verify local server is running
+curl http://localhost:8000/health
+
+# Check ngrok status
+ngrok status
+```
+
+**2. AI Agent Can't Connect:**
+- Try asking the AI Agent simple questions in the chat:
+  ```
+  "What Odoo models are available?"
+  "Can you search for customers?"
+  ```
+- Check if the AI responds with Odoo data or error messages
+- Verify the MCP Server URL is correct in the AI Agent settings
+- Ensure the ngrok tunnel is still active (check ngrok dashboard)
+
+**3. Authentication Issues:**
+- If you configured basic authentication in ngrok, ensure the AI Agent settings include the credentials
+- Test in the AI chat by asking: "Can you access the Odoo system?"
+- Check the AI Agent's MCP Server configuration for authentication settings
+- Verify the ngrok tunnel is configured with the same auth credentials
+
+### Integration Examples
+
+#### Flowhunt Flow Configuration
+**In Flowhunt Dashboard:**
+
+1. **Flow Structure:**
+   ```
+   [Input/Trigger] → [AI Agent] → [Output/Action]
+                        ↓
+                   [Chat History]
+                        ↓
+                   [MCP Server] ← ngrok URL
+   ```
+
+2. **AI Agent MCP Settings:**
+   - **MCP Server URL**: `https://abc123.ngrok-free.app`
+   - **Connection Type**: HTTP/HTTPS
+   - **Authentication**: None (or Basic Auth if configured)
+   - **Available Tools**: All 12 Odoo MCP tools will be automatically detected
+
+3. **Flow Example Configuration:**
+   ```yaml
+   Flow Name: "Odoo Customer Management"
+   Components:
+     - Input: Webhook/API trigger
+     - AI Agent: 
+       - Model: GPT-4 or Claude
+       - MCP Server: https://abc123.ngrok-free.app
+       - Chat History: Enabled
+     - Output: Email notification or webhook response
+   ```
+
+#### Custom AI Agent Integration
+```python
+import requests
+
+class RemoteOdooMCPClient:
+    def __init__(self, ngrok_url, auth=None):
+        self.base_url = ngrok_url.rstrip('/')
+        self.auth = auth
+    
+    def call_tool(self, tool_name, **kwargs):
+        response = requests.post(
+            f"{self.base_url}/",
+            json={
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/call",
+                "params": {
+                    "name": tool_name,
+                    "arguments": kwargs
+                }
+            },
+            auth=self.auth
+        )
+        return response.json()
+
+# Usage
+client = RemoteOdooMCPClient("https://abc123.ngrok-free.app")
+customers = client.call_tool("search_records", model="res.partner", limit=10)
+```
+
+This setup enables powerful AI-driven automation of your Odoo business processes through secure remote access!
+
+## Custom MCP Server Development
+We develop MCP Servers for customers, if you need MCP server for your own system similar to Odoo MCP server, please contact us (https://www.flowhunt.io/contact/). 
+Here is the description how we develop MCP Servers for our customers: https://www.flowhunt.io/services/mcp-server-development/
+
+## Demo
+
+📺 [Watch the demo on YouTube](https://youtu.be/tanzyt_qEmE)
+
+
+## Features
+
+- 🔍 **Search Records**: Query any Odoo model with complex domain filters
+- ➕ **Create Records**: Add new records to any Odoo model
+- ✏️ **Update Records**: Modify existing records
+- 🗑️ **Delete Records**: Remove records from the system
+- 📊 **Read Records**: Fetch detailed information about specific records
+- 📋 **List Models**: Discover available models in your Odoo instance
+- 🔧 **Model Introspection**: Get field definitions for any model
+- 🌐 **HTTP Streaming**: Full MCP Streamable HTTP transport support
+- 🐳 **Docker Ready**: Complete containerization with Docker Compose
+- 🔄 **Server-Sent Events**: Real-time streaming responses
+- 🛡️ **Security**: Origin validation, CORS support, and session management
+- 📊 **Monitoring**: Health checks, metrics, and observability
+
+## Installation
+
+### 🐳 Docker (Recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+
+# Copy environment file and configure
+cp .env.example .env
+# Edit .env with your Odoo credentials
+
+# Start with Docker Compose
+docker-compose up -d
+```
+
+### 📦 Via pip
+
+```bash
+pip install odoo-mcp-server
+```
+
+### 🔧 From source
+
+```bash
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+pip install -e .
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file in your project directory or set these environment variables:
+
+```env
+ODOO_URL=https://your-instance.odoo.com
+ODOO_DB=your-database-name
+ODOO_USERNAME=your-username@example.com
+ODOO_API_KEY=your-api-key-here
+```
+
+### Getting Odoo Credentials
+
+1. **API Key**: 
+   - Log into your Odoo instance
+   - Go to Settings → Users & Companies → Users
+   - Select your user
+   - Under "API Keys" or "Security" tab, create a new API key
+   - Copy the key immediately (it won't be shown again)
+
+2. **Database Name**:
+   - Usually visible in the URL when logged in
+   - Or check Settings → Activate Developer Mode → Database Info
+
+3. **Username**:
+   - Your login email address
+
+## 🚀 Quick Start
+
+### Docker Deployment
+
+1. **Clone and configure**:
+```bash
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+```
+
+2. **Configure your Odoo credentials**:
+```bash
+# Copy the example file
+cp docker-compose.example.yml docker-compose.yml
+
+# Edit docker-compose.yml with your Odoo credentials
+nano docker-compose.yml
+```
+
+Or edit the environment section directly:
+```yaml
+environment:
+  - ODOO_URL=https://your-instance.odoo.com
+  - ODOO_DB=your-database-name
+  - ODOO_USERNAME=your-username@example.com
+  - ODOO_API_KEY=your-api-key-here
+```
+
+3. **Start the services**:
+```bash
+# Basic deployment
+docker-compose up -d
+
+# With monitoring stack
+docker-compose --profile monitoring up -d
+
+# With nginx proxy
+docker-compose --profile proxy up -d
+```
+
+4. **Access the server**:
+- **MCP Endpoint**: `http://localhost:8000/mcp` or `http://localhost:8000/` (POST)
+- **Health Check**: `http://localhost:8000/health`
+- **API Documentation**: `http://localhost:8000/docs`
+- **Server Info**: `http://localhost:8000/` (GET)
+
+### Local Development
+
+```bash
+# Install dependencies
+pip install -e .
+
+# Set environment variables
+export ODOO_URL="https://your-instance.odoo.com"
+export ODOO_DB="your-database"
+export ODOO_USERNAME="your-email@example.com"
+export ODOO_API_KEY="your-api-key"
+
+# Run the HTTP server
+python -m mcp_server_odoo
+```
+
+## 🔌 Client Integration
+
+### MCP Server Inspector
+
+The server is fully compatible with the MCP Server Inspector. Use these connection settings:
+
+- **URL**: `http://localhost:8000`
+- **Method**: `POST`
+- **Content-Type**: `application/json`
+- **Endpoint**: `/` (root endpoint)
+
+The server automatically handles both GET (server info) and POST (MCP protocol) requests on the root endpoint.
+
+### HTTP Streaming Client
+
+Connect to the MCP server using HTTP streaming transport:
+
+```python
+import httpx
+import json
+
+# Initialize session
+response = httpx.post(
+    "http://localhost:8000/mcp",
+    json={
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "initialize",
+        "params": {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {"name": "test-client", "version": "1.0.0"}
+        }
+    },
+    headers={"Accept": "application/json, text/event-stream"}
+)
+
+# Get session ID from response headers
+session_id = response.headers.get("Mcp-Session-Id")
+
+# Make tool calls
+response = httpx.post(
+    "http://localhost:8000/mcp",
+    json={
+        "jsonrpc": "2.0",
+        "id": 2,
+        "method": "tools/call",
+        "params": {
+            "name": "search_records",
+            "arguments": {
+                "model": "res.partner",
+                "domain": [["is_company", "=", True]],
+                "limit": 10
+            }
+        }
+    },
+    headers={
+        "Mcp-Session-Id": session_id,
+        "Accept": "application/json, text/event-stream"
+    }
+```
+
+### Server-Sent Events (SSE) Streaming
+
+For real-time streaming responses:
+
+```python
+import httpx
+import json
+
+# Stream responses using SSE
+with httpx.stream(
+    "POST",
+    "http://localhost:8000/mcp",
+    json={
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "name": "search_records",
+            "arguments": {
+                "model": "res.partner",
+                "domain": [["is_company", "=", True]],
+                "limit": 10
+            }
+        }
+    },
+    headers={"Accept": "text/event-stream"}
+) as response:
+    for line in response.iter_lines():
+        if line.startswith("data: "):
+            data = json.loads(line[6:])  # Remove "data: " prefix
+            print(f"Received: {data}")
+```
+
+### JSON Integration
+
+The server provides a comprehensive JSON API for direct integration with any application. All MCP protocol methods are available via standard HTTP POST requests.
+
+#### Basic JSON Request Format
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "method_name",
+  "params": {
+    "parameter1": "value1",
+    "parameter2": "value2"
+  }
+}
+```
+
+#### Example: Initialize Connection
+
+```bash
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "initialize",
+    "params": {
+      "protocolVersion": "2024-11-05",
+      "capabilities": {},
+      "clientInfo": {"name": "my-app", "version": "1.0.0"}
+    }
+  }'
+```
+
+#### Example: List Available Tools
+
+```bash
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 2,
+    "method": "tools/list",
+    "params": {}
+  }'
+```
+
+#### Example: Call a Tool
+
+```bash
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 3,
+    "method": "tools/call",
+    "params": {
+      "name": "search_records",
+      "arguments": {
+        "model": "res.partner",
+        "limit": 5
+      }
+    }
+  }'
+```
+
+#### JavaScript/Node.js Integration
+
+```javascript
+const axios = require('axios');
+
+class OdooMCPClient {
+  constructor(baseUrl = 'http://localhost:8000') {
+    this.baseUrl = baseUrl;
+    this.requestId = 1;
+  }
+
+  async call(method, params = {}) {
+    const response = await axios.post(this.baseUrl, {
+      jsonrpc: "2.0",
+      id: this.requestId++,
+      method: method,
+      params: params
+    }, {
+      headers: { 'Content-Type': 'application/json' }
+    });
+    
+    return response.data.result;
+  }
+
+  async searchRecords(model, options = {}) {
+    return this.call('tools/call', {
+      name: 'search_records',
+      arguments: { model, ...options }
+    });
+  }
+
+  async createRecord(model, values) {
+    return this.call('tools/call', {
+      name: 'create_record',
+      arguments: { model, values }
+    });
+  }
+}
+
+// Usage
+const client = new OdooMCPClient();
+const partners = await client.searchRecords('res.partner', { limit: 10 });
+console.log(partners);
+```
+
+#### Python Integration
+
+```python
+import requests
+import json
+
+class OdooMCPClient:
+    def __init__(self, base_url="http://localhost:8000"):
+        self.base_url = base_url
+        self.request_id = 1
+    
+    def call(self, method, params=None):
+        payload = {
+            "jsonrpc": "2.0",
+            "id": self.request_id,
+            "method": method,
+            "params": params or {}
+        }
+        self.request_id += 1
+        
+        response = requests.post(
+            self.base_url,
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        return response.json()["result"]
+    
+    def search_records(self, model, **options):
+        return self.call("tools/call", {
+            "name": "search_records",
+            "arguments": {"model": model, **options}
+        })
+    
+    def create_record(self, model, values):
+        return self.call("tools/call", {
+            "name": "create_record",
+            "arguments": {"model": model, "values": values}
+        })
+
+# Usage
+client = OdooMCPClient()
+partners = client.search_records("res.partner", limit=10)
+print(partners)
+```
+
+#### MCP Client Integration
+
+For Claude Desktop, Cursor, or other MCP clients, use this configuration:
+
+**Claude Desktop** (`claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "odoo-mcp-server": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "http://localhost:8000"
+      ]
+    }
+  }
+}
+```
+
+**Cursor** (`.cursor/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "odoo-mcp-server": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "http://localhost:8000"
+      ]
+    }
+  }
+}
+```
+
+**Setup Steps:**
+1. Start your MCP server: `docker-compose up -d`
+2. Install mcp-remote: `npm install -g mcp-remote`
+3. Add the configuration above to your MCP client
+4. Restart your MCP client
+5. You'll have access to all 12 Odoo tools!
+
+**✅ Current Status:** 
+- HTTP JSON-RPC endpoints work correctly via `curl`
+- All 12 Odoo tools are fully functional
+- Server connects to Odoo and executes operations successfully
+
+**Working Configuration for JSON-RPC:**
+```bash
+# Test via curl (this works):
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "tools/call",
+    "params": {
+      "name": "search_count",
+      "arguments": {"model": "res.partner"}
+    }
+  }'
+```
+
+## Available Tools
+
+- **search_records** - Search for records in any Odoo model
+- **get_record** - Get detailed information about specific records
+- **create_record** - Create new records in Odoo
+- **update_record** - Update existing records
+- **delete_record** - Delete records from Odoo
+- **list_models** - Discover available models in your Odoo instance
+- **get_model_fields** - Get field definitions for a model
+
+## 🐳 Docker Services
+
+### Core Services
+
+- **mcp-server**: Main MCP server with HTTP streaming
+- **redis**: Session management and caching (optional)
+- **nginx**: Reverse proxy with SSL termination (optional)
+
+### Service Management
+
+```bash
+# Start basic services
+docker-compose up -d
+
+# Start with Redis for session management
+docker-compose --profile redis up -d
+
+# Start with Nginx reverse proxy
+docker-compose --profile proxy up -d
+
+# View logs
+docker-compose logs -f mcp-server
+
+# Scale services
+docker-compose up -d --scale mcp-server=3
+
+# Update services
+docker-compose pull
+docker-compose up -d
+
+# Stop services
+docker-compose down
+
+# Clean up
+docker-compose down -v --remove-orphans
+```
+
+### Endpoints
+
+- **MCP Endpoint**: `http://localhost:8000/mcp` or `http://localhost:8000/` (POST)
+- **Health Check**: `http://localhost:8000/health`
+- **API Documentation**: `http://localhost:8000/docs`
+- **Server Info**: `http://localhost:8000/` (GET)
+
+## 🔧 Development
+
+### Local Development Setup
+
+```bash
+# Clone repository
+git clone https://github.com/vzeman/odoo-mcp-server.git
+cd odoo-mcp-server
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Set up environment
+cp .env.example .env
+# Edit .env with your configuration
+
+# Run the server
+python -m mcp_server_odoo
+```
+
+### Testing
+
+```bash
+# Install test dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run with coverage
+pytest --cov=mcp_server_odoo
+
+# Test HTTP endpoints
+curl -X POST http://localhost:8000/mcp \
+  -H "Content-Type: application/json" \
+  -H "Accept: application/json, text/event-stream" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'
+```
+
+### Code Quality
+
+```bash
+# Type checking
+mypy mcp_server_odoo
+
+# Linting and formatting
+ruff check .
+ruff format .
+
+# Security scanning
+bandit -r mcp_server_odoo
+```
+
+### Docker Development
+
+```bash
+# Build development image
+docker build -t odoo-mcp-server:dev .
+
+# Run development container
+docker run -p 8000:8000 \
+  -e ODOO_URL="https://demo.odoo.com" \
+  -e ODOO_DB="demo" \
+  -e ODOO_USERNAME="demo" \
+  -e ODOO_API_KEY="your-key" \
+  odoo-mcp-server:dev
+
+# Development with volume mounting
+docker run -p 8000:8000 \
+  -v $(pwd)/mcp_server_odoo:/app/mcp_server_odoo \
+  -e ODOO_URL="https://demo.odoo.com" \
+  odoo-mcp-server:dev
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Support
+
+For issues and feature requests, please use the [GitHub issue tracker](https://github.com/vzeman/odoo-mcp-server/issues).