InsightPulse Connection Manager

When to Use This Skill

Use this skill when you need to:

• Manage multiple database and API connections for Finance SSC operations
• Generate connection strings, .env files, or Docker Compose configs
• Test and monitor connection health across infrastructure
• Integrate Supabase, Odoo, Superset, MCP servers, and PostgreSQL
• Build self-hosted connection management without vendor lock-in
• Create unified connection dashboard for multi-agency operations

Core Capabilities

Connection Management

• Unified interface for all connections (Supabase, Odoo, Superset, MCP, PostgreSQL, APIs)
• Pre-configured connections for InsightPulse AI stack
• Support for 8 agencies: RIM, CKVC, BOM, JPAL, JLI, JAP, LAS, RMQB
• Color-coded connection types with visual status indicators

Auto-Generated Configuration

• Connection string generation (PostgreSQL, MySQL, MongoDB formats)
• Environment variables in .env format with copy-to-clipboard
• Docker Compose service definitions
• Kubernetes ConfigMap snippets

Connection Testing & Monitoring

• One-click connection testing
• Real-time connection health monitoring
• Active connection count tracking
• Connection latency measurement

Beautiful UI

• Supabase-inspired Kanban interface
• Color-coded by connection type
• Visual status indicators (green/yellow/red)
• Quick-access copy buttons

Prerequisites

Required Software

• Odoo 19 Community Edition
• PostgreSQL 16+ (for connection testing)
• Python 3.11+ with psycopg2

Optional Integrations

• Supabase project (ref: spdtwktxdalcfigzeqrz)
• Apache Superset instance
• MCP servers (Notion, Google Drive)
• DigitalOcean PostgreSQL cluster

Access Requirements

• Odoo administrator access
• Database credentials for systems being managed
• API keys for external services

Implementation Patterns

Module Structure

insightpulse_connection_manager/
├── __init__.py
├── __manifest__.py
├── models/
│   ├── __init__.py
│   └── connection_endpoint.py      # Main model
├── views/
│   ├── connection_endpoint_views.xml
│   └── connection_endpoint_kanban.xml
├── security/
│   ├── ir.model.access.csv
│   └── connection_security.xml
├── data/
│   └── default_endpoints.xml       # Pre-configured connections
└── static/
    ├── description/
    │   └── index.html
    └── src/
        └── scss/
            └── connection_manager.scss

Model Definition

# models/connection_endpoint.py
from odoo import models, fields, api
import psycopg2

class ConnectionEndpoint(models.Model):
    _name = 'insightpulse.connection.endpoint'
    _description = 'Connection Endpoint'
    _order = 'sequence, name'

    name = fields.Char(required=True)
    connection_type = fields.Selection([
        ('supabase', 'Supabase'),
        ('postgresql', 'PostgreSQL'),
        ('odoo', 'Odoo Database'),
        ('superset', 'Apache Superset'),
        ('mcp', 'MCP Server'),
        ('api', 'REST API'),
    ], required=True)
    
    base_url = fields.Char(string='Server/Host')
    port = fields.Integer(default=5432)
    database_name = fields.Char()
    username = fields.Char()
    password = fields.Char()
    api_key = fields.Char()
    
    connection_string = fields.Text(compute='_compute_connection_string')
    env_vars = fields.Text(compute='_compute_env_vars')
    docker_compose = fields.Text(compute='_compute_docker_compose')
    
    status = fields.Selection([
        ('draft', 'Not Tested'),
        ('success', 'Connected'),
        ('failed', 'Failed'),
    ], default='draft')
    
    @api.depends('connection_type', 'base_url', 'port', 'database_name', 'username', 'password')
    def _compute_connection_string(self):
        for rec in self:
            if rec.connection_type in ['supabase', 'postgresql', 'odoo']:
                rec.connection_string = (
                    f"postgresql://{rec.username}:{rec.password}@"
                    f"{rec.base_url}:{rec.port}/{rec.database_name}"
                )
            elif rec.connection_type == 'superset':
                rec.connection_string = f"http://{rec.base_url}:{rec.port}"
            else:
                rec.connection_string = f"{rec.base_url}"
    
    @api.depends('name', 'connection_string')
    def _compute_env_vars(self):
        for rec in self:
            safe_name = rec.name.upper().replace(' ', '_').replace('-', '_')
            rec.env_vars = (
                f"{safe_name}_URL={rec.connection_string}\n"
                f"{safe_name}_USER={rec.username}\n"
                f"{safe_name}_PASSWORD={rec.password}"
            )
    
    def action_test_connection(self):
        """Test database connection"""
        for rec in self:
            try:
                if rec.connection_type in ['supabase', 'postgresql', 'odoo']:
                    conn = psycopg2.connect(rec.connection_string)
                    conn.close()
                    rec.status = 'success'
                    return {
                        'type': 'ir.actions.client',
                        'tag': 'display_notification',
                        'params': {
                            'message': f'✅ Connected to {rec.name}',
                            'type': 'success',
                            'sticky': False,
                        }
                    }
            except Exception as e:
                rec.status = 'failed'
                return {
                    'type': 'ir.actions.client',
                    'tag': 'display_notification',
                    'params': {
                        'message': f'❌ Connection failed: {str(e)}',
                        'type': 'danger',
                        'sticky': True,
                    }
                }

View Definition (Kanban)

<!-- views/connection_endpoint_kanban.xml -->
<record id="view_connection_endpoint_kanban" model="ir.ui.view">
    <field name="name">insightpulse.connection.endpoint.kanban</field>
    <field name="model">insightpulse.connection.endpoint</field>
    <field name="arch" type="xml">
        <kanban class="o_kanban_mobile" sample="1">
            <field name="id"/>
            <field name="name"/>
            <field name="connection_type"/>
            <field name="status"/>
            <field name="connection_string"/>
            <templates>
                <t t-name="kanban-box">
                    <div class="oe_kanban_global_click o_kanban_record_has_image_fill">
                        <div class="o_kanban_record_top">
                            <div class="o_kanban_record_headings">
                                <strong class="o_kanban_record_title">
                                    <field name="name"/>
                                </strong>
                                <span class="badge badge-pill" 
                                      t-attf-class="badge-{{status == 'success' and 'success' or status == 'failed' and 'danger' or 'secondary'}}">
                                    <field name="status"/>
                                </span>
                            </div>
                        </div>
                        <div class="o_kanban_record_body">
                            <field name="connection_type" widget="badge"/>
                            <div class="text-muted">
                                <i class="fa fa-server"/> <field name="base_url"/>:<field name="port"/>
                            </div>
                        </div>
                        <div class="o_kanban_record_bottom">
                            <div class="oe_kanban_bottom_left">
                                <button type="object" name="action_test_connection" 
                                        class="btn btn-sm btn-secondary">
                                    <i class="fa fa-plug"/> Test
                                </button>
                            </div>
                            <div class="oe_kanban_bottom_right">
                                <button type="object" name="action_copy_connection_string"
                                        class="btn btn-sm btn-link">
                                    <i class="fa fa-clipboard"/> Copy
                                </button>
                            </div>
                        </div>
                    </div>
                </t>
            </templates>
        </kanban>
    </field>
</record>

Default Data

<!-- data/default_endpoints.xml -->
<odoo>
    <data noupdate="1">
        <!-- Supabase Production -->
        <record id="endpoint_supabase_prod" model="insightpulse.connection.endpoint">
            <field name="name">Supabase Production</field>
            <field name="connection_type">supabase</field>
            <field name="base_url">db.spdtwktxdalcfigzeqrz.supabase.co</field>
            <field name="port">5432</field>
            <field name="database_name">postgres</field>
            <field name="username">postgres</field>
            <field name="sequence">10</field>
        </record>

        <!-- Odoo Database -->
        <record id="endpoint_odoo_db" model="insightpulse.connection.endpoint">
            <field name="name">Odoo 19 Database</field>
            <field name="connection_type">odoo</field>
            <field name="base_url">localhost</field>
            <field name="port">5432</field>
            <field name="database_name">odoo19</field>
            <field name="username">odoo</field>
            <field name="sequence">20</field>
        </record>

        <!-- Apache Superset -->
        <record id="endpoint_superset" model="insightpulse.connection.endpoint">
            <field name="name">Apache Superset Dashboard</field>
            <field name="connection_type">superset</field>
            <field name="base_url">localhost</field>
            <field name="port">8088</field>
            <field name="username">admin</field>
            <field name="sequence">30</field>
        </record>

        <!-- MCP Server - Notion -->
        <record id="endpoint_mcp_notion" model="insightpulse.connection.endpoint">
            <field name="name">MCP Server - Notion</field>
            <field name="connection_type">mcp</field>
            <field name="base_url">http://localhost:3000</field>
            <field name="sequence">40</field>
        </record>
    </data>
</odoo>

Integration Points

With Odoo Finance Modules

# Access connections from other modules
connection = self.env['insightpulse.connection.endpoint'].search([
    ('name', '=', 'Supabase Production')
], limit=1)

if connection:
    # Use connection string for external API calls
    import requests
    response = requests.get(
        f"{connection.connection_string}/rest/v1/bir_forms",
        headers={'apikey': connection.api_key}
    )

With Superset Dashboards

# Auto-configure Superset database connections
superset_conn = self.env['insightpulse.connection.endpoint'].search([
    ('connection_type', '=', 'superset')
], limit=1)

# Generate Superset database URI
db_uri = f"postgresql+psycopg2://{username}:{password}@{host}:{port}/{database}"

With MCP Servers

# Manage MCP server endpoints
mcp_servers = self.env['insightpulse.connection.endpoint'].search([
    ('connection_type', '=', 'mcp')
])

for server in mcp_servers:
    # Register MCP server URL for bridge connections
    mcp_config[server.name] = {
        'url': server.base_url,
        'api_key': server.api_key,
    }

Output Formats

Connection String

postgresql://postgres:[email protected]:5432/postgres

Environment Variables

SUPABASE_PRODUCTION_URL=postgresql://postgres:[email protected]:5432/postgres
SUPABASE_PRODUCTION_USER=postgres
SUPABASE_PRODUCTION_PASSWORD=password

Docker Compose

services:
  app:
    environment:
      - DATABASE_URL=postgresql://postgres:[email protected]:5432/postgres

BIR Compliance Integration

Connection for BIR Systems

<record id="endpoint_bir_portal" model="insightpulse.connection.endpoint">
    <field name="name">BIR eFPS Portal API</field>
    <field name="connection_type">api</field>
    <field name="base_url">https://efps.bir.gov.ph</field>
    <field name="api_key">YOUR_BIR_API_KEY</field>
</record>

Usage in BIR Module

# Fetch BIR connection for form submission
bir_conn = self.env['insightpulse.connection.endpoint'].search([
    ('name', 'ilike', 'BIR')
], limit=1)

# Submit Form 1601-C via API
import requests
response = requests.post(
    f"{bir_conn.base_url}/api/submit/1601-c",
    headers={'Authorization': f'Bearer {bir_conn.api_key}'},
    json=form_data
)

Security Best Practices

Access Control

<!-- security/connection_security.xml -->
<record id="group_connection_manager" model="res.groups">
    <field name="name">Connection Manager</field>
    <field name="category_id" ref="base.module_category_administration"/>
</record>

<record id="group_connection_admin" model="res.groups">
    <field name="name">Connection Administrator</field>
    <field name="category_id" ref="base.module_category_administration"/>
    <field name="implied_ids" eval="[(4, ref('group_connection_manager'))]"/>
</record>

Password Encryption

from cryptography.fernet import Fernet

def _encrypt_password(self, password):
    """Encrypt sensitive credentials"""
    key = self.env['ir.config_parameter'].sudo().get_param('connection.encryption.key')
    f = Fernet(key.encode())
    return f.encrypt(password.encode()).decode()

def _decrypt_password(self, encrypted_password):
    """Decrypt credentials for use"""
    key = self.env['ir.config_parameter'].sudo().get_param('connection.encryption.key')
    f = Fernet(key.encode())
    return f.decrypt(encrypted_password.encode()).decode()

Examples

Example 1: Multi-Agency Database Connections

# Create connections for 8 agencies
agencies = ['RIM', 'CKVC', 'BOM', 'JPAL', 'JLI', 'JAP', 'LAS', 'RMQB']

for agency in agencies:
    self.env['insightpulse.connection.endpoint'].create({
        'name': f'{agency} Database',
        'connection_type': 'postgresql',
        'base_url': 'db.spdtwktxdalcfigzeqrz.supabase.co',
        'port': 5432,
        'database_name': f'{agency.lower()}_db',
        'username': 'postgres',
        'password': os.getenv(f'{agency}_DB_PASSWORD'),
    })

Example 2: Connection Health Dashboard

def get_connection_health_dashboard(self):
    """Generate health metrics for all connections"""
    connections = self.env['insightpulse.connection.endpoint'].search([])
    
    health_data = {
        'total': len(connections),
        'active': len(connections.filtered(lambda c: c.status == 'success')),
        'failed': len(connections.filtered(lambda c: c.status == 'failed')),
        'not_tested': len(connections.filtered(lambda c: c.status == 'draft')),
        'by_type': {}
    }
    
    for conn_type in ['supabase', 'postgresql', 'odoo', 'superset', 'mcp', 'api']:
        type_conns = connections.filtered(lambda c: c.connection_type == conn_type)
        health_data['by_type'][conn_type] = len(type_conns)
    
    return health_data

Example 3: Auto-Generate .env File

def generate_env_file(self):
    """Generate complete .env file for deployment"""
    connections = self.env['insightpulse.connection.endpoint'].search([])
    
    env_content = "# InsightPulse AI - Connection Configuration\n"
    env_content += "# Auto-generated from Connection Manager\n\n"
    
    for conn in connections:
        safe_name = conn.name.upper().replace(' ', '_').replace('-', '_')
        env_content += f"# {conn.name}\n"
        env_content += f"{safe_name}_URL={conn.connection_string}\n"
        env_content += f"{safe_name}_USER={conn.username}\n"
        env_content += f"{safe_name}_PASSWORD={conn.password}\n"
        if conn.api_key:
            env_content += f"{safe_name}_API_KEY={conn.api_key}\n"
        env_content += "\n"
    
    return env_content

Cost Savings

By using this self-hosted connection manager:

• No vendor lock-in: Own your infrastructure
• Zero licensing costs: Open-source solution
• Integrated workflow: All connections in one place
• Replaces: Paid connection management tools ($50-200/month)

Annual Savings: $600-2,400

Production Deployment

Installation

# Copy module to Odoo addons
cp -r insightpulse_connection_manager /odoo/addons/

# Update module list in Odoo
# Apps → Update Apps List

# Install module
# Apps → Search "InsightPulse Connection Manager" → Install

Docker Deployment

# docker-compose.yml
services:
  odoo:
    image: odoo:19
    volumes:
      - ./insightpulse_connection_manager:/mnt/extra-addons/insightpulse_connection_manager

Kubernetes Deployment

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: odoo
spec:
  template:
    spec:
      containers:
      - name: odoo
        volumeMounts:
        - name: addons
          mountPath: /mnt/extra-addons/insightpulse_connection_manager

Troubleshooting

Connection Test Fails

# Check psycopg2 is installed
pip install psycopg2-binary

# Verify firewall rules
# Ensure port 5432 is open for PostgreSQL connections

# Check credentials
# Verify username/password in Supabase/Odoo settings

Permission Denied

# Add user to connection manager group
# Settings → Users → Select User → Groups → Add "Connection Manager"

License

LGPL-3.0 (required for Odoo modules)

References

• Supabase Connection Strings
• Odoo 19 Models Guide
• Apache Superset Database Connections
• MCP Protocol

Built for Finance Shared Service Centers managing multi-agency operations with self-hosted infrastructure.