GibsonAI MCP Server: AI Cloud Database Platform

Overview

The GibsonAI MCP Server implements a Model Context Protocol (MCP) for managing AI-focused cloud databases and their runtime contexts. It centralizes lifecycle operations — provisioning, migration, scaling, backups, and access control — so teams can treat AI data stores (vector DBs, feature stores, embeddings stores) as managed services without writing orchestration glue.

MCP is intended for developers and SREs who need repeatable, observable, and automated workflows for AI databases. By exposing APIs and CLI tooling, the server enables programmatic creation of isolated instances, rolling migrations, autoscaling policies, and audit-ready operations that integrate with CI/CD and cloud platforms.

Features

• Instance orchestration: create, update, delete AI database instances via API or CLI
• Schema and migration management for model context stores
• Autoscaling and capacity policies (horizontal/vertical) based on metrics
• Snapshotting, backups, and scheduled restores
• Multi-tenant isolation and RBAC primitives
• Rolling upgrades, canary deploys, and zero-downtime migrations
• Observability hooks: metrics, logs, health checks, and events
• Pluggable storage and compute backends (cloud object stores, container runtimes)
• REST and gRPC APIs, plus a lightweight CLI for automation
• Kubernetes and Docker deployment examples (Helm manifests included in repo)

Installation / Configuration

Quickstart (local Docker):

# clone the repo
git clone https://github.com/GibsonAI/mcp.git
cd mcp

# build a local Docker image (if you want to customize)
docker build -t gibsonai/mcp:local .

# run with a simple configuration file
docker run --rm -p 8080:8080 \
  -v "$(pwd)/config.yaml:/etc/mcp/config.yaml:ro" \
  gibsonai/mcp:local

Docker Compose example:

version: "3.8"
services:
  mcp:
    image: gibsonai/mcp:latest
    ports:
      - "8080:8080"
    volumes:
      - ./config.yaml:/etc/mcp/config.yaml:ro
    environment:
      - MCP_LOG_LEVEL=info
      - MCP_DB_URL=postgres://mcp:mcp@postgres:5432/mcp
  postgres:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: mcp

Kubernetes (minimal Deployment):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mcp
  template:
    metadata:
      labels:
        app: mcp
    spec:
      containers:
      - name: mcp
        image: gibsonai/mcp:latest
        env:
        - name: MCP_DB_URL
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: db-url
        ports:
        - containerPort: 8080
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 20

Configuration keys (example in config.yaml):

server:
  bind: "0.0.0.0:8080"
storage:
  backend: "postgres"
  dsn: "postgres://user:pass@host:5432/mcp"
auth:
  jwt_secret: "replace-with-secure-secret"
observability:
  metrics_endpoint: "/metrics"
  enable_tracing: true

Available Tools / Resources

• GitHub repository: https://github.com/GibsonAI/mcp
• REST API endpoints for instance lifecycle, scaling, and backups
• gRPC API for low-latency integrations
• CLI (mcpctl) for scripting and CI/CD
• Helm charts and Kubernetes manifests for production deployment
• Example Terraform and CI pipeline snippets in the repo
• OpenAPI / protobuf API specs included in repo for client generation

Component overview:

Use Cases

• Provisioning per-model vector stores

  • A data scientist requests an isolated embeddings DB for an experiment. Use the API:

    curl -X POST http://localhost:8080/v1/instances \
      -H "Authorization: Bearer ${TOKEN}" \
      -H "Content-Type: application/json" \
      -d '{"name":"exp-123-emb","plan":"small","region":"us-west-2"}'
    

  • The server provisions resources, initializes schema, and returns connection details.

• Rolling migration between backends

  • Migrate a production instance from an on-prem store to a cloud-hosted managed service. MCP performs staged migration: create replica, sync data, cutover, and validate client connections without downtime.

• Autoscaling for inference-heavy workloads

  • Attach a policy that scales instance worker pools based on CPU/latency or custom metrics (e.g., embeddings requests per second). Policies can be defined in config or via the API and enforced by the orchestration layer.

• Disaster recovery and backups

  • Schedule daily snapshots, replicate to a secondary region, and run automated restore tests. Restores can be executed via CLI:

    mcpctl restore --instance exp-123-emb --snapshot 2026-04-01T02:00:00Z
    

• Multi-tenant SaaS offering

  • Use MCP to manage isolated per-customer contexts, enforce quotas, and integrate with billing or tenant lifecycle hooks.

Getting Help

• Open an issue or browse examples on the GitHub repo: https://github.com/GibsonAI/mcp
• Refer to the included API specs for client generation and automation patterns
• Use the CLI help to discover commands:

  mcpctl --help
  

This document provides the high-level workflow and practical commands to get started. For production deployments, review the Helm charts, configure secrets and observability integrations, and validate backup/restore procedures in a staged environment.