ChatSuite

The Complete AI Collaboration Platform - Connect LibreChat, n8n, MindsDB, NocoDB, MinIO, and MCPHub for seamless productivity

---

• Contributing: see CONTRIBUTING.md and our CODE_OF_CONDUCT.md.

What is ChatSuite?

ChatSuite is a comprehensive AI collaboration platform that unifies multiple powerful tools into one cohesive workspace:

Core AI Productivity Tools:

• LibreChat - Advanced AI chat interface with multi-model support
• n8n - Visual workflow automation and integration platform
• MindsDB - AI-powered database with ML capabilities
• NocoDB - Smart spreadsheet interface for databases
• MinIO - S3-compatible object storage for scalable file management
• MCPHub - Model Context Protocol server orchestration
• MCP Email - Email integration via Model Context Protocol

Development Foundation:

• React Frontend - Starter client application demonstrating modern UI patterns
• NestJS API - Example backend service showcasing scalable architecture

Key Features

Seamless AI Tool Integration

• Unified Workspace - All AI productivity tools accessible from one platform
• Centralized Configuration - Single point of management for all services
• Cross-Tool Data Flow - Seamless information sharing between LibreChat, n8n, MindsDB, and NocoDB

Intelligent Automation & Orchestration

• Visual Workflows - Connect AI models to real-world data with n8n automations
• Smart Email Processing - MCP Email integration for intelligent email handling
• Dynamic MCP Orchestration - MCPHub enables seamless service communication
• AI-Powered Analytics - MindsDB brings machine learning to your databases

Maximum Productivity

• One-Click Deployment - Complete platform launches with single command
• Real-time Collaboration - Share insights across LibreChat, workflows, and databases
• Automated Task Management - Reduce manual work through intelligent automation

Enterprise Ready

• Docker-Based Architecture - Consistent deployment across environments
• Comprehensive Monitoring - Built-in logging and health checks
• Scalable Foundation - Modern TypeScript/React/NestJS stack for custom development

Quick Start

Get ChatSuite running quickly (time varies by network and machine):

Clone the repository and install dependencies:

git clone https://github.com/hubertusgbecker/chatsuite.git
cd chatsuite
pnpm install

Setup environment configuration (create a runtime .env and copy templates for each environment):

cp .env.example .env
cp config/env/env.dev config/env/.env.dev
cp config/env/env.qa config/env/.env.qa
cp config/env/env.host config/env/.env.host

Set your preferred environment (dev/qa/host). The root .env controls which environment is active:

pnpm env:set:dev  # or pnpm env:set:qa or pnpm env:set:host

Generate SSL certificates for HTTPS (optional, recommended for nginx):

brew install mkcert
mkcert -install
mkcert -key-file config/certificates/localhost-key.pem \
  -cert-file config/certificates/localhost-crt.pem \
  localhost 127.0.0.1 ::1

Configure MCPHub (required for MCP server integration):

# Copy the example configuration to create your settings file
cp config/mcphub/mcp_settings.json.example config/mcphub/mcp_settings.json

Note: mcp_settings.json is not tracked in version control and must be created for each installation, similar to .env files. The example file provides a template with recommended MCP server configurations.

Launch the entire platform:

pnpm start

All services will start automatically with proper dependencies.

Production Deployment

For production or fresh installations, use the two-step deployment process:

# Step 1: Rebuild the entire system
pnpm rebuild

# Step 2: Verify all services are working
pnpm test

# Or run both commands sequentially
pnpm rebuild && pnpm test

What each command does:

• pnpm rebuild:

  • Stops and cleans existing containers
  • Pulls latest service images
  • Starts all services in correct order
  • Waits for core services initialization

• pnpm test:

  • Tests all service endpoints
  • Verifies MCP server integration
  • Displays comprehensive system status
  • Confirms system is ready for use

Access Your Platform

Once running, access these powerful productivity tools through your browser:

Service	Purpose	Direct Access	Primary Focus
LibreChat	Multi-Model AI Chat	localhost:3080	Core AI Interface
n8n	Visual Workflow Automation	localhost:5678	Productivity Automation
NocoDB	Smart Database Interface	localhost:8080	Data Management
MindsDB	AI-Powered Database	localhost:47334	ML Analytics
MinIO	S3 Object Storage	localhost:9001	File Storage & Management
MCPHub	Protocol Orchestration	localhost:3000	Service Integration
Email MCP	Email Intelligence	localhost:9557	Smart Email Processing
Client App	Development Starter	localhost:4200	Custom Development
API Service	Example Backend	localhost:3333	API Development
PgAdmin	Database Admin	localhost:8081 (or via proxy https://localhost:10443/pgadmin/)	Database Management

Nginx Reverse Proxy

• Port: 10443 (HTTPS ready when certificates configured)
• Purpose: Unified access point for all services
• Security: SSL termination and request routing

Proxy routes (examples — see config/nginx/default.dev.conf for exact mappings):

• / → client-app:4200
• /api/ → api-customer-service:3333
• /n8n/ → n8n:5678
• /nocodb/ → nocodb:8080
• /minio/ → minio:9001 (Console)
• /minio-api/ → minio:9000 (S3 API)
• /pgadmin/ → pgadmin:80

Platform Commands

Master ChatSuite with these essential commands:

Core Operations

pnpm start              # Launch all services
pnpm stop               # Graceful shutdown
pnpm rebuild            # Complete system rebuild
pnpm test               # Comprehensive health checks

Health & Monitoring

pnpm check              # Verify dependencies
pnpm env:show           # Display current environment
pnpm env:verify         # Security configuration check

Environment Management

pnpm start:workspace:dev    # Development environment
pnpm start:workspace:qa     # QA environment
pnpm start:workspace:host   # Production environment

Architecture Overview

ChatSuite is built on modern, enterprise-grade architecture:

Technology Stack

• Frontend: React 18 + TypeScript + Tailwind CSS
• Backend: NestJS + Node.js + TypeScript
• Database: PostgreSQL + MongoDB (LibreChat)
• Container: Docker + Docker Compose
• Build System: Nx Monorepo + pnpm
• Automation: n8n workflows + GitHub Actions

Service Architecture

ChatSuite AI Productivity Platform
├── Nginx Proxy (SSL Termination & Routing)
├── LibreChat (Multi-Model AI Chat)
├── n8n (Visual Workflow Automation)
├── MindsDB (AI-Powered Database)
├── NocoDB (Smart Database Interface)
├── MinIO (S3-Compatible Object Storage)
├── MCPHub (Protocol Orchestration Hub)
├── MCP Email (Intelligent Email Integration)
├── PostgreSQL (Primary Database)
├── React Client (Development Starter App)
└── NestJS API (Development Example Service)

Security & Compliance

• MIT License for maximum flexibility
• Environment-based configuration
• Containerized isolation
• Centralized logging and monitoring

Developer Guide: All development standards and guidelines are defined in AGENTS.md

Platform Capabilities

Integrated AI Productivity Suite

• Multi-Model AI Chat - LibreChat with OpenAI, Claude, Gemini, and more
• Visual Workflow Automation - n8n with 200+ integrations for seamless productivity
• AI-Powered Database Intelligence - MindsDB with ML predictions and insights
• Smart Data Management - NocoDB for intuitive database operations
• S3-Compatible Object Storage - MinIO for scalable file and media storage
• Dynamic Protocol Orchestration - MCPHub for seamless service communication
• Intelligent Email Processing - MCP Email server for smart email automation

Seamless Integration & Collaboration

• Unified Data Flow - Connect insights from LibreChat directly to n8n workflows
• Cross-Platform Analytics - Share data between NocoDB, MindsDB, and automation tools
• Real-time Orchestration - MCPHub enables dynamic service coordination
• Centralized Management - Single platform for all AI productivity tools

Development Foundation

• Nx Monorepo - Scalable workspace with dependency graphs for custom development
• React Starter App - Modern client application template with best practices
• NestJS Example API - Backend service template demonstrating scalable architecture
• Docker Compose - Complete containerized development environment
• TypeScript - Type-safe development across the entire stack
• Hot Reload - Instant feedback during development

Production Ready

• Environment Management - Dev, QA, and production configurations
• Health Monitoring - Comprehensive service health checks
• Security Scanning - Automated dependency vulnerability checks
• Performance Optimization - Built-in caching and optimization
• Scalable Architecture - Microservices with clear boundaries
• Kubernetes Deployment - Cloud-native orchestration (planned)

Development Setup

Prerequisites & Setup

Find the perfect place to start by following these steps:

1. Install NVM (Node Version Manager):

   • NVM Installation Guide
   • In the project root, run:

     nvm use

     If this fails, check the required Node version in .nvmrc and run:

     nvm install $(cat .nvmrc)
     nvm use

2. Install Docker:

   • Docker Installation Guide
   • Verify installation:

     docker --version && docker-compose --version

3. Install pnpm:

   • This repo uses pnpm for efficient dependency management.

     npm install -g pnpm

4. Generate .env files:

   • Copy all files in config/env/ and prefix each with a dot (.) to make them hidden and git-ignored:

     cp config/env/env.dev config/env/.env.dev
     cp config/env/env.host config/env/.env.host
     cp config/env/env.qa config/env/.env.qa

5. SSL Setup (Recommended for HTTPS):

   • Install mkcert (easiest via Homebrew):

     brew install mkcert
     mkcert -install
     cd config/certificates
     mkcert -key-file localhost-key.pem -cert-file localhost-crt.pem localhost host.minikube.internal 0.0.0.0 127.0.0.1 ::1

6. MCPHub Configuration (Required):

   • Copy the example MCP settings to create your configuration:

     cp config/mcphub/mcp_settings.json.example config/mcphub/mcp_settings.json

   • This file is not tracked in version control, similar to .env files
   • The example provides pre-configured MCP servers (time, fetch, email, browser-use)
   • Customize as needed based on your available MCP servers

7. Install dependencies:

   pnpm install

8. Start the platform:

   pnpm start

   Wait for all Docker containers to be up, then navigate to http://localhost:3080 for LibreChat (or use the unified proxy at https://localhost:10443/), or http://localhost:4200 for the main dashboard.

You're ready to go! The platform will automatically start all services with proper dependencies.

Development Workflow

Core Applications

ChatSuite's main value comes from the seamless integration of AI productivity tools. The platform also includes starter applications for custom development:

AI Productivity Suite:

• LibreChat, n8n, MindsDB, NocoDB, MCPHub, and MCP Email work together to create a unified AI collaboration environment

Development Starters:

• client-app - React SPA template demonstrating modern UI patterns and integration approaches
• api-customer-service - NestJS REST API example showing scalable backend architecture

Development Commands

# Start full platform (recommended)
pnpm start

# Development environments
pnpm start:workspace:dev    # Point to DEV backend services
pnpm start:workspace:qa     # Point to QA backend services
pnpm start:workspace:host   # Point to production services

# Client-only development
pnpm start:client:dev       # Client app with DEV API
pnpm start:client:qa        # Client app with QA API

# Maintenance
pnpm stop                   # Graceful shutdown
pnpm stop:prune            # Complete cleanup (removes containers & images)

Testing & Quality

# Run all tests
pnpm nx:test

# Run tests for changed code only
pnpm nx:test:affected

# Build for production
pnpm nx:build

# Development without Docker (not recommended)
pnpm nx:start

Code Generation

# Generate new library
nx g @nx/react:lib my-library

# Generate new component
nx g @nx/react:component my-component --project=client-app

# View dependency graph
nx graph

Pro Tip: All libraries are importable as @chatsuite/library-name for clean imports.

Contributing & Support

Development Philosophy

ChatSuite follows strict Test-Driven Development (TDD) and Incremental Development practices:

• TDD: Always write tests before implementation (Red-Green-Refactor cycle)
• Incremental: Break all work into small steps (15-30 minutes each)
• Quality: Every commit should include tests and pass all checks
• Documentation: Code changes require documentation updates

See CONTRIBUTING.md for detailed workflow and examples.

Documentation

• AGENTS.md - Complete development guidelines and architecture
• CONTRIBUTING.md - TDD workflow and contribution process
• Environment Docs - Configuration and deployment guides
• Integration Testing Strategy - Comprehensive testing guide
• Nx Documentation - Monorepo tooling and best practices

Issues & Support

• Report bugs and request features via GitHub Issues

• Follow coding standards defined in AGENTS.md

• All contributions welcome under MIT License

• For confidential reports related to harassment or security, see CODE_OF_CONDUCT.md or email the maintainers at hubertus@hubertusbecker.com.

License

This project is licensed under the MIT License - use it freely for personal and commercial projects.

---

Configuration Documentation

All configuration and environment documentation for ChatSuite—including setup, environment management, and service-specific configuration—is centrally maintained in /config/README.md. This file provides a comprehensive overview and links to detailed documentation for each integrated service and environment. For any configuration or environment-related questions, always refer to /config/README.md first.

Built with ChatSuite - The Complete AI Collaboration Platform

Star on GitHub • Documentation • Report Issues