Happy Vertical Corporation - AI-Powered Development Frameworks

Augmenting Human Intelligence with AI

At Happy Vertical Corporation, we believe the right approach is to augment your human resources, not replace them. By automating mundane, repetitive tasks, AI frees your team to focus on the creative, strategic, and rewarding aspects of their work.

Our frameworks—SMRT and the Happy Vertical SDK—provide powerful, flexible tools that make AI-augmented applications simple to build and maintain. More importantly, we've eliminated the false choice between rapid prototyping and production readiness. Our adapter-based architecture means your proof-of-concept code is your production code. Start with SQLite on your laptop, scale to PostgreSQL on Kubernetes—same codebase, just different configuration.

s-m-r-t

Define Once, Generate Everything

Building AI-powered applications typically means writing the same logic three times: once for your business logic, again for your API endpoints, and yet again for AI function calling. SMRT eliminates this redundancy with a simple decorator: @smrt().

Class Definition typescript
import { SmrtObject, SmrtCollection, smrt } from '@happyvertical/smrt-core';

// Custom collection with custom methods
class Todos extends SmrtCollection<Todo> {
  async listIncomplete() {
    return this.list({ where: { done: false } });
  }
}

@smrt({
  api: { include: ['list', 'get', 'create', 'update', 'delete'] },
  mcp: true,
  cli: true,
  collection: Todos
})
class Todo extends SmrtObject {
  title: string = '';
  done: boolean = false;
  dueDate?: Date;

  async markComplete(): Promise<void> {
    this.done = true;
    await this.save();
  }
}

Programmatic Usage:

Working with Collections typescript
import { ObjectRegistry } from '@happyvertical/smrt-core';

// Get collection (returns Todos custom collection)
const todos = await ObjectRegistry.getCollection('Todo', {
  db: { type: 'sqlite', url: 'data.db' },
  ai: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY }
});

// Create and save
const todo = await todos.create({ title: 'Review PRs' });
await todo.save();

// Use custom collection method
const incomplete = await todos.listIncomplete();

// Call custom instance method
await todo.markComplete();

AI-Powered Methods:

Every object automatically gets AI-powered methods. The do() method can call your custom methods via function calling:

do(), is(), describe() typescript
// AI-powered methods on every object:

// do() - AI can call your custom methods automatically
await todo.do('Mark this task as complete');
// → AI sees markComplete() and calls it via function calling

// is() - AI evaluates conditions
const isUrgent = await todo.is('This is urgent or high priority');
// → Returns true/false

// describe() - AI generates descriptions
const summary = await todo.describe();
// → Returns human-readable description

What You Get Automatically:

REST API - Full CRUD endpoints generated automatically
MCP Server - AI function calling (Claude, code editors, etc.)
CLI Commands - Development and operations tools
Database Schema - Inferred from your TypeScript types
AI Methods - do(), is(), describe() on every instance

Scale Without Refactoring:

Start with SQLite on your laptop. Scale to PostgreSQL on Kubernetes. Same codebase, just change the config:

Zero Refactoring - Just Config typescript
// smrt.config.ts - Development (SQLite)
export default {
  database: {
    adapter: 'sqlite',
    path: './data.db'
  }
};

// smrt.config.ts - Production (PostgreSQL)
export default {
  database: {
    adapter: 'postgres',
    connection: {
      host: process.env.DB_HOST,
      pool: { min: 5, max: 20 },
      ssl: { rejectUnauthorized: true }
    }
  }
};

View Documentation View on GitHub

Happy Vertical SDK

Flexible, Open-Source Foundation

The AI landscape changes rapidly—new models, new providers, new best practices emerge constantly. Building production applications on this shifting foundation requires careful architecture. The Happy Vertical SDK solves this with a simple principle: adapter-based abstractions that provide stability without sacrificing flexibility.

Adapter Pattern - Prototype to Production typescript
import { createAI } from '@happyvertical/ai';
import { createDatabase } from '@happyvertical/sql';
import { createFiles } from '@happyvertical/files';

// Development: Local everything
const ai = createAI({ provider: 'openai', apiKey: process.env.OPENAI_KEY });
const db = createDatabase({ adapter: 'sqlite', path: './app.db' });
const files = createFiles({ adapter: 'local', basePath: './uploads' });

// Production: Scale without refactoring
const ai = createAI({ provider: 'anthropic', apiKey: process.env.ANTHROPIC_KEY });
const db = createDatabase({
  adapter: 'postgres',
  host: 'postgres-primary.cluster.local',
  pool: { min: 10, max: 50 }
});
const files = createFiles({
  adapter: 's3',
  bucket: 'my-app-uploads',
  region: 'us-east-1'
});