postgresml

Trains classification and regression models directly within PostgreSQL using pgml.train() SQL function, with bindings to scikit-learn, XGBoost, and LightGBM via pyo3 Python integration layer. Models are persisted in the database as versioned artifacts with automatic hyperparameter tuning and cross-validation, eliminating data movement between application and model servers. The extension uses Rust's pgrx framework to expose these ML operations as native SQL functions that execute within the PostgreSQL process.

Generates dense vector embeddings from text using transformer models (BERT, Sentence Transformers, etc.) via pgml.embed() SQL function, with GPU acceleration when available. Embeddings are stored as native PostgreSQL vector columns and indexed using approximate nearest neighbor (ANN) algorithms (HNSW, IVFFlat) for sub-millisecond semantic search. The system uses the Hugging Face Transformers library via pyo3 bindings to load and execute models in-process, avoiding serialization overhead.

Provides SQL functions for common data preprocessing tasks (normalization, encoding, imputation, feature scaling) that execute within PostgreSQL. These functions operate on table columns and return transformed data that can be directly used for model training. The system supports both numeric and categorical transformations, with parameters stored for consistent application during inference.

Combines predictions from multiple trained models using ensemble methods (voting, averaging, stacking) via SQL functions. The system trains meta-models that learn optimal weighting of base model predictions, improving overall accuracy. Ensemble predictions are executed as a single SQL query that calls multiple model inference functions and combines results according to the ensemble strategy.

Trains and deploys time-series forecasting models (ARIMA, exponential smoothing, neural networks) using pgml.train() with time-series-specific algorithms. Models learn temporal patterns and seasonality from historical data, then generate future predictions. The system handles time-indexed data, lag features, and rolling window validation automatically. Predictions include confidence intervals for uncertainty quantification.

Splits long documents into semantically coherent chunks using pgml.chunk() SQL function with configurable strategies (sliding window, sentence-aware, paragraph-aware). Chunks are stored with metadata (source, offset, chunk_id) and can be directly embedded and indexed for RAG retrieval. The function handles overlapping windows to preserve context across chunk boundaries and supports multiple languages via language-specific tokenizers.

Performs semantic search using pgvector's native vector type combined with HNSW (Hierarchical Navigable Small World) or IVFFlat approximate nearest neighbor indexes. Queries use cosine similarity, L2 distance, or inner product operators to find k-nearest neighbors in sub-millisecond time. The system automatically manages index creation and tuning parameters (ef_construction, ef_search for HNSW; lists, probes for IVFFlat) based on dataset size.

Exposes PostgresML as an OpenAI-compatible LLM API server, allowing any client using OpenAI SDK to query models hosted in PostgreSQL. The system supports streaming responses, function calling, and chat completions. Models can be deployed from Hugging Face or custom fine-tuned models, with inference executed on GPU when available. The API layer handles tokenization, prompt formatting, and response streaming without requiring application-level integration changes.

Executes pre-trained transformer models for NLP tasks (text classification, named entity recognition, question answering, summarization) via pgml.transform() SQL function. Models are loaded from Hugging Face and executed with GPU acceleration. Results are returned as structured data (labels, scores, entities, answers) that can be directly stored in PostgreSQL tables or used in downstream SQL queries. The system handles tokenization, batching, and result formatting automatically.

Manages trained model artifacts as versioned database objects with automatic tracking of training parameters, metrics, and deployment status. The pgml.deploy() function activates a specific model version for production inference, while pgml.models and pgml.deployments tables maintain audit trails. Models are stored as serialized objects in the database with metadata (algorithm, hyperparameters, training date, performance metrics), enabling rollback and A/B testing of different versions.

Provides a Python SDK (Korvus) that wraps PostgresML SQL functions with a high-level API for training, inference, and RAG pipeline construction. The SDK handles connection pooling, error handling, and result marshaling, allowing Python developers to build ML workflows without writing SQL. It supports both synchronous and asynchronous operations and integrates with LangChain for RAG applications.

Provides a web-based dashboard (pgml-dashboard) for visualizing trained models, monitoring inference performance, and managing deployments. The dashboard displays model metrics, training history, prediction latency, and resource usage. It includes a SQL editor for running queries and a model registry interface for version management. Built with React and TypeScript, it connects to PostgreSQL via a REST API layer.

Combines embedding generation, vector search, and LLM inference into a cohesive RAG pipeline within PostgreSQL. The system orchestrates document chunking, embedding, indexing, and retrieval in a single transaction, then passes retrieved context to an LLM for generation. The Korvus SDK provides high-level abstractions for RAG workflows, while raw SQL allows fine-grained control. Results include both retrieved documents and generated responses with source attribution.