Building Blocks

An AI-powered idea repository that transforms how you capture, organize, and synthesize creative thoughts. Building Blocks uses artificial intelligence to discover hidden connections between your ideas and facilitate meaningful synthesis.

Architecture

Backend: FastAPI with SQLAlchemy ORM, featuring structured logging and OpenAI integration for intelligent idea analysis. RESTful API endpoints support CRUD operations, AI categorization, connection detection, and idea synthesis.

Frontend: Vue 3 with TypeScript, utilizing Pinia for state management and GSAP for smooth animations. Features a custom SCSS design system with glassmorphism effects, responsive design, and comprehensive dark mode support.

Data Visualization: D3.js powers interactive network visualizations that reveal relationships between ideas, enabling exploration of conceptual connections.

Core Features

Idea Management: Create, organize, and categorize ideas with file attachments and tagging.

AI-Powered Insights: Automatic categorization, connection detection between related concepts, and guided synthesis of multiple ideas into cohesive new concepts.

Network Visualization: Interactive graphs showing idea relationships with strength indicators and connection reasoning.

Discovery Engine: AI-generated suggestions for new explorations based on existing idea patterns.

Evolution Timeline

Evolution Timeline: Track how ideas develop and connect over time.

Design Philosophy

Built on the principle that great ideas emerge from connections. The interface emphasizes visual clarity and smooth interactions to reduce cognitive load while exploring complex idea networks. The glassmorphism design language creates depth without distraction, supporting both focused work and exploratory browsing.

Technology Stack

Backend: Python 3.12, FastAPI, SQLAlchemy, OpenAI API, WebSockets
Frontend: Vue 3, TypeScript, Vite, GSAP, D3.js, SCSS
Desktop: Tauri (Rust) for native cross-platform applications
Database: SQLite with full relationship mapping
Infrastructure: Structured logging, CORS-enabled API, file upload handling

🖥️ Desktop Application

Building Blocks is available as a native desktop application built with Tauri, providing:

• Native Performance: Rust-powered backend with web frontend
• Cross-Platform: Available for macOS, Windows, and Linux
• File System Access: Direct access to local files and directories
• Native Notifications: Desktop notifications for important events
• System Integration: Proper OS-level integration and security

Quick Start (Desktop)

# Development mode
./dev.sh

# Build for production
./build.sh

# Build debug version
./build.sh --debug

Development Options

# Backend only (API server)
./dev.sh --backend-only

# Frontend only (web dev server)
./dev.sh --frontend-only

# Tauri only (assumes backend is running)
./dev.sh --tauri-only

🚀 Getting Started

Prerequisites

• Node.js 18+ and npm
• Python 3.12+
• Rust (latest stable) - for desktop builds
• OpenAI API Key - for AI features

Installation

1. Clone the repository

   git clone https://github.com/yourusername/Building-Blocks.git
   cd Building-Blocks

2. Set up the backend

   cd backend
   python3 -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   pip install -r requirements.txt

3. Configure environment

   cp env.example .env
   # Edit .env with your OpenAI API key

4. Install frontend dependencies

   cd ../frontend
   npm install

5. Install root dependencies (for Tauri)

   cd ..
   npm install

Running the Application

Web Version:

# Start backend
cd backend && source venv/bin/activate && python main.py

# Start frontend (in another terminal)
cd frontend && npm run dev

Desktop Version:

# Development mode with hot reload
./dev.sh

# Or step by step:
cd backend && source venv/bin/activate && python main.py &
npm run tauri:dev

Building for Production

Web Build:

npm run frontend:build

Desktop Build:

# Cross-platform build
./build.sh

# Debug build (faster, larger)
./build.sh --debug

# Skip frontend rebuild
./build.sh --skip-frontend

🏗️ Architecture

Desktop Integration

The Tauri application provides a seamless bridge between the web frontend and native desktop capabilities:

• Frontend: Vue.js application served locally
• Backend: Python FastAPI server (runs independently)
• Desktop Shell: Tauri (Rust) provides native window management and system APIs
• Communication: HTTP/WebSocket between frontend and backend, Tauri APIs for system integration