13.
HN
Sqlx4k: A couroutine-first SQL toolkit for Kotlin Multiplatform
sqlx4k is a coroutine-first SQL toolkit tailored for Kotlin Multiplatform projects, supporting PostgreSQL, MySQL/MariaDB, and SQLite databases. Unlike an ORM, it offers primitives and utilities designed to facilitate direct communication with the database while ensuring compile-time query validations to prevent runtime errors. The toolkit prioritizes extensibility through plugins such as PGMQ for PostgreSQL and seamless integration with SQLDelight.
Key features of sqlx4k include configurable connection pooling that allows setting minimum and maximum connections, transaction isolation level control, and coroutine-based query execution facilitated by the `QueryExecutor` interface. It supports both manual and automatic acquisition of database connections, prepared statements, custom value converters, and transaction management within coroutines through the use of a `TransactionContext`. Additionally, sqlx4k provides code generation for CRUD operations using the KSP plugin, enabling syntax checking and optional schema validation against migrations.
The toolkit is equipped with capabilities for batch operations and repository hooks, which can be utilized to implement cross-cutting concerns like logging and tracing. Extensions further enhance its functionality by adding support for PostgreSQL message queues (PGMQ) and integrating SQLDelight. sqlx4k emphasizes non-blocking I/O to ensure high performance in applications and offers comprehensive documentation, examples, and multi-platform support while being licensed under MIT.
Keywords: #phi4, Batch Operations, CRUD Repository, Code-Generation, Compile-time validation, Connection Pool, ContextCrudRepository, Coroutine-first, Custom Value Converters, Database Migrations, Extensions, Kotlin Multiplatform, Listen/Notify, Memory leaks, MySQL/MariaDB, Non-blocking I/O, PGMQ, PostgreSQL, Property-Level Converters, QueryExecutor, Repository Hooks, Rust toolchain, SQL schema validation, SQL syntax validation, SQL toolkit, SQLDelight, SQLite, Transaction Isolation Level
github.com an hour ago
|
14.
HN
Metriport (YC S22) is hiring a security engineer to harden healthcare infra
Metriport (YC S22), an open-source data intelligence platform specializing in healthcare organizations, is actively recruiting a security engineer based in San Francisco or the Bay Area. The company integrates with major U.S. healthcare IT systems to facilitate real-time access and exchange of patient data for over 300 million individuals. Boasting product-market fit, significant funding, strong VC support, and rapid scaling, Metriport prides itself on its high-performing team composed largely of former founders who value autonomy, competence, and sustainable work intensity. The security engineer role entails comprehensive management of security projects from inception to production deployment, encompassing tasks such as implementing audit logging solutions, RBAC (Role-Based Access Control), and internal policy revisions. Additional responsibilities include advocating for security best practices across teams, assisting with PR reviews and customer assessments, enhancing development security protocols, managing Linear tasks, participating in planning sessions, and attending daily stand-ups.
Candidates are expected to have over six years of experience in security engineering, familiarity with HIPAA environments, and proficiency in various security frameworks and technologies including SOC 2, NIST, AWS cloud services, and encryption protocols. The position offers competitive compensation packages that include equity options, a generous salary range, comprehensive health coverage, flexible work arrangements, on-site meals, company off-sites, a provided MacBook, unlimited paid time off (PTO), and commitment to equal employment opportunities.
Metriport fosters an inclusive workplace culture and utilizes cutting-edge technologies such as React, Node.js, TypeScript, AWS services, PostgreSQL, DynamoDB, S3, Snowflake, FHIR servers, and Oneleet for security. The company is dedicated to maintaining diversity in its team and operations.
Keywords: #phi4, AWS Cloud Services, Data Intelligence, DynamoDB, Engineering-Heavy Team, Equal Employment Opportunities, FHIR Servers, Flat Structure, HIPAA Compliance, Healthcare Infrastructure, High Autonomy, Multi-Million ARR, Nodejs, Oneleet, Open-Source Platform, PostgreSQL, Product-Market Fit, React, Real-Time Exchange, S3, SOC 2 Framework, Security Engineer, Snowflake, TypeScript, US IT Systems
www.ycombinator.com an hour ago
|
15.
HN
Open source courses for modern web developers
The Dev Handbook is an open-source platform that offers free developer courses on various technologies, including React, TypeScript, JavaScript, Vue, Svelte, Python, Django, Go, Rust, Ruby, PHP, Laravel, NestJS, Redis, and PostgreSQL. Created by Stanza, it aims to provide high-quality learning materials featuring theory, code examples, and best practices. With 130 courses encompassing over 2,100 lessons across 17 technologies, the platform enhances user engagement through interactive challenges, real-time validation, and progress tracking via Mana points, with seamless integration in VS Code.
Stanza encourages community involvement by allowing contributions to improve content quality and suggesting new topics on its Issues page. The platform's materials are shared under a Creative Commons Attribution-ShareAlike 4.0 International License, permitting users to read, share, translate, and enhance them while offering code examples for unrestricted use under the MIT License. However, using forked material for commercial purposes without proper attribution is prohibited. This initiative underscores Stanza's commitment to fostering a collaborative learning environment by emphasizing open-source accessibility and community-driven content enhancement.
Keywords: #phi4, CC BY-SA 40, Django, Go, IDE, JavaScript, Laravel, MIT, Mana points, NestJS, Open source, PHP, PostgreSQL, Python, React, Redis, Ruby, Rust, Stanza, Svelte, TypeScript, VS Code, Vue, code examples, contributing, courses, credit, forking, free, improvements, interactive challenges, issues, learning, paid course, practice, professional environment, progress tracking, real-time validation, repo, sharing, streaks, topics, translation, typo fixes, web developers
github.com an hour ago
|
22.
HN
Turbocharging PostgreSQL Listen/Notify with 40x Boost
The article centers on a substantial advancement in PostgreSQL's Listen/Notify feature, achieving up to a 40-fold performance improvement by leveraging advanced turbocharging techniques to enhance database communication efficiency. Although the author includes personal details about relocating from Delhi to Hyderabad and bringing their car for daily use, these elements are unrelated to the core subject of technological optimization within PostgreSQL systems. The main focus is on how this enhancement significantly improves the speed and effectiveness of inter-process communication in databases, thereby optimizing overall system performance.
Keywords: #phi4, Boost, Car, Day-to-day use, Delhi, Fac, Hyderabad, Listen/Notify, PostgreSQL, Registered, Technical keywords, Turbocharging
www.robins.in 2 hours ago
|
27.
HN
OpenAPI to SQL SDK
The experimental SQL SDK generator transforms OpenAPI specifications into PostgreSQL extensions, allowing REST API calls to function as SQL functions. This innovation enables a typed interface for executing API queries directly within PostgreSQL using standard SQL syntax, thereby eliminating the need for ETL scripts and sync pipelines. Key features include mapping each API endpoint to a corresponding SQL function and resource to schema, utilizing composite types instead of JSONB for type safety, and handling pagination with recursive Common Table Expressions (CTEs) in PostgreSQL. This setup efficiently manages pagination by adjusting HTTP requests based on the rows processed.
The tool's integration capabilities allow it to combine API data with existing database tables without traditional ETL processes, making it suitable for analytical queries, scheduled jobs, batch pipelines, and business analytics tasks like revenue reconciliation and customer segmentation. It also facilitates SQL-based inference calls in batch workflows involving large language models (LLMs). However, its use is not recommended for low-latency Online Transaction Processing (OLTP) systems due to network latency inherent in HTTP requests, and changing queries can lead to inefficient remote API call plans.
The tool avoids the complexities of Foreign Data Wrappers (FDWs), which are less effective over HTTP and struggle with non-relational data, by offering SQL functions that align closely with existing API structures. Currently experimental, it focuses on OpenAPI 3.x specifications with predictable pagination, primarily demonstrated through Stripe's OpenAPI but designed for broader applicability. Developers interested in early access or feedback can try the Stripe SQL SDK or sign up to generate extensions for their APIs, keeping in mind potential breaking changes as development progresses.
Keywords: #phi4, ETL scripts, Foreign Data Wrappers, HTTP requests, OpenAPI, PL/Python, PostgreSQL, REST API, SQL SDK, analytical queries, composite types, materialized views, pagination, pg_cron
www.stainless.com 2 hours ago
|
70.
HN
Pg_ClickHouse: Fastest Postgres Extension on ClickBench
In December 2025, the pg_clickhouse PostgreSQL extension was introduced to facilitate seamless querying of ClickHouse from within PostgreSQL, requiring minimal migration effort for users. Designed to reduce the load on PostgreSQL by offloading analytics execution tasks to ClickHouse, this approach contrasts with other extensions that perform analytics internally in PostgreSQL and are limited by a single node's resources. The architecture of pg_clickhouse supports independent scaling and prevents resource contention within PostgreSQL, significantly enhancing performance for queries involving complex aggregations through effective query pushdown.
In January 2026, the extension was evaluated using ClickBench, where it emerged as the fastest among PostgreSQL extensions, achieving performance metrics closely aligned with native ClickHouse on both ARM64 and AMD64 instances. The benchmark confirmed that pg_clickhouse supports a comprehensive range of operations, including COUNT(), SUM(), GROUP BY, ORDER BY, HAVING clauses, and more, through effective aggregate and expression pushdown to ClickHouse. Efforts are ongoing to expand support for more complex query structures such as subqueries and common table expressions (CTEs). Users can access the open-source version via a quickstart guide or utilize it within a managed PostgreSQL service, facilitating easy integration and use.
Keywords: #phi4, AMD64, ARM64, CTEs, ClickBench, ClickHouse, Pg_ClickHouse, PostgreSQL, aggregate pushdown, aggregation, analytics, benchmarking, extension, network round-trip, performance, query pushdown, result conversion, subqueries, transactional queries
clickhouse.com 5 hours ago
|
91.
HN
Token_ledger – Ruby gem for auditable token accounting in Rails
TokenLedger is a Ruby gem specifically designed for Rails applications to manage token accounting using double-entry bookkeeping principles, ensuring transactional integrity through atomic operations and idempotency. It supports features such as balance caching, polymorphic owner support, and audit trails, all while maintaining thread safety with pessimistic locking mechanisms to prevent race conditions and overdrafts. Core functionalities include the ability to deposit, spend, reserve, capture, and release tokens while tracking transactions using external IDs to prevent duplicates.
The gem emphasizes secure handling of irreversible API calls through a Reserve/Capture/Release pattern and offers efficient balance lookups via cached balances. TokenLedger integrates with existing Rails models and can be configured with custom owner types or seed accounts for token sources and sinks, backed by database-level constraints to maintain data integrity. Its robust testing framework covers functionality, concurrency, and thread safety, recommending PostgreSQL for its superior performance under high-concurrency scenarios.
In production environments, the gem advises using PostgreSQL for optimal operation, regularly reconciling cached balances, archiving old transactions, and implementing logging, alerts, and rate limiting to ensure system stability. Troubleshooting involves addressing balance discrepancies by recalculating balances and auditing specific users' ledger entries for anomalies. TokenLedger is tailored for Rails applications that require reliable financial data management with strong auditability and security in concurrent environments.
Keywords: #phi4, ActiveRecord, ImbalancedTransactionError, LedgerAccount, PostgreSQL, Rails, Ruby, SQLite, Stripe integration, TokenLedger, account balance, account types, adjustment transactions, adjustments, asset-style accounting, atomic transactions, audit, audit trails, balance caching, balance operations, batch operations, cached balance, capture, concurrency, configuration, data integrity, database constraints, deposit, double-entry accounting, duplicate transactions, error handling, expenses, external API calls, idempotency, idempotency keys, immutability, index optimization, integer amounts, ledger entries, liabilities, locking, manageradjust, manual credits, migration, migrations, performance considerations, pessimistic locking, polymorphic owners, production recommendations, rate limiting, reconciliation, release, reserve, reserve/capture/release, reversals, spend, testing, tests, thread safety, thread-safe operations, transaction type, transactions, troubleshooting, uniqueness constraints, webhook handler
github.com 6 hours ago
|
113.
HN
Show HN: Kkr-Query2xlsx – SQL Runner to XLSX/CSV (GUI+CLI, SQLite Demo)
Kkr-Query2xlsx is a user-friendly tool designed to run SQL queries from `.sql` files and export the results into Excel (XLSX) or CSV formats, catering both to non-developers with its GUI interface built using Tkinter and to those preferring command-line operations. It supports various databases like SQLite, SQL Server, PostgreSQL, and MySQL. The application allows for customized exports by providing template support for XLSX formatting and customizable options for CSV outputs, such as delimiter choices and encoding settings. A notable feature is the integrated SQLite demo that enables users to test its functionality without any setup. Additionally, it includes retry handling mechanisms for deadlocks and configurable export settings to enhance usability.
For Windows users, the application simplifies usage by not requiring Python installation or manual configurations at first run. However, developers or those on non-Windows systems can opt to use the tool from source, which necessitates Python and its dependencies. This makes Kkr-Query2xlsx suitable for analysts, operations personnel, and small teams needing repeatable exports of SQL query results for internal reporting purposes, though it is not intended as a full-fledged BI platform with dashboards or ETL capabilities.
The application further supports efficient data handling through features like local configuration files (e.g., secure.txt), CSV profiles, and export timeouts. It is open-source under the MIT license, encouraging community involvement and contributions while providing avenues for feedback.
Keywords: #phi4, Archiving, Automation, Beta Testers, CLI, CSV, Configuration, Connection, Demo, Dependencies, Export, GUI, Headless, Language Support, License, MIT, MySQL, Non-Interactive Mode, ODBC, Portability, PostgreSQL, Python, Quality-of-Life Features, Queries, Release, Retry Handling, SQL, SQLite, Security, Self-Test, Templates, Timeout, Tkinter, Troubleshooting, Unit Tests, Windows, XLSX
github.com 8 hours ago
https://github.com/kkrysztofczyk/kkr-query2xlsx/is 7 hours ago
|
137.
HN
Show HN: ReciPath – open-source, offline-first recipe and storage manager
ReciPath is an open-source application designed for managing recipes, shopping lists, and pantry storage, focusing on offline-first functionality while leveraging Supabase for secure data storage. The app enables users to save recipes complete with images, track pantry ingredients, generate shopping lists tailored from selected recipes, and utilize a dashboard to analyze cooking habits. It offers two versions: the free version supports local usage and syncing of shopping lists, whereas the Pro version allows cloud synchronization of all data for an annual fee of €4.99. Users can engage in various tasks including creating and managing recipes, planning shopping trips, monitoring pantry stock levels, and recording cooking times. ReciPath is developed using Flutter on the frontend and integrates a Supabase backend with a PostgreSQL database, encouraging community contributions under the MIT License.
Keywords: #phi4, Flutter, MIT License, MIT License Keywords: ReciPath, PostgreSQL, Pro version, ReciPath, charts, cross-platform, dashboard, grocery conversion, nutrition analysis, offline-first, open-source, pantry tracking, recipe manager, recipes, shopping lists, storage manager, supabase, syncing
github.com 10 hours ago
https://github.com/Cunibon/recipath 9 hours ago
https://play.google.com/store/apps/details?id=com. 9 hours ago
|
138.
HN
The Next Version of Curling IO
Curling IO is implementing an extensive platform upgrade to enhance its reliability and scalability over the next twenty years, without affecting current user experience. This involves transitioning from a Ruby on Rails infrastructure to one based on Gleam, which compiles to Erlang for backend operations and JavaScript for frontend tasks. The shift to Gleam offers significant benefits in terms of concurrency management, fault tolerance, and error detection at compile time—advantages that surpass those provided by the existing Rails framework.
The updated system will integrate AI agent APIs and improve performance during peak usage through enhanced concurrency handling. Additionally, it aims to simplify developer onboarding with robust type safety and establish shared data types between client and server for greater efficiency. A notable change is the switch from PostgreSQL to SQLite as the database solution, chosen for its operational simplicity, cost-effectiveness, and anticipated performance improvements due to in-process execution.
To ensure a smooth transition, Curling IO plans to run parallel versions of the platform throughout development and testing phases, allowing for seamless adoption when Curling IO Version 3 is finalized. Future discussions will explore bilingual support and compile-time guarantees as part of this strategic upgrade.
Keywords: #phi4, AI Agent APIs, BEAM VM, Concurrency, Curling IO, Developer Onboarding, Functional Patterns, Gleam, Infrastructure, PostgreSQL, PostgreSQL Keywords: Curling IO, Rails, SQLite, Technical Upgrades, Type Safety, Version 3
curling.io 10 hours ago
|
164.
HN
TaskForge – auditable, secure, framework for OpenClaw
TaskForge is an independent agent orchestration layer designed to bolster security for AI agents using OpenClaw by employing a sandboxed environment through Docker containers. It enforces capability-based security where agents begin with limited permissions and need explicit human consent to access additional capabilities, resulting in the creation of a new immutable Docker image each time a feature is approved. Key features include isolated execution within Docker-in-Docker environments, controlled permission levels via capability gating, support for multiple large language model providers through a unified interface, and complete logging of all interactions for traceability. TaskForge also offers durable workflows that can withstand crashes and allow pausing or resuming for approvals.
The setup process requires Docker 24+ and adequate system resources, involving cloning the repository, setting environment variables, starting services via a Makefile, and verifying their health using a user interface for task management. The architecture comprises interconnected services like a control plane, image builder, temporal worker, and frontend dashboard, all coordinated with Docker Compose and supported by PostgreSQL for database management. Developed by Roman Pawel Klis from Dr. sc. ETH Zurich, TaskForge targets secure, enterprise-scale AI solutions in regulated environments and is maintained independently of OpenClaw. Discussions about its applications can be facilitated through LinkedIn.
Keywords: #phi4, API, Agents, Approval, Audit, Data Architecture, Docker, FastAPI, Generative AI, Nextjs, OpenClaw, Orchestration, PostgreSQL, Sandbox, Security, TaskForge, Workflow
github.com 13 hours ago
|
179.
HN
pg_ash: Active Session History for PostgreSQL wait event sampling
pg_ash is a sophisticated tool designed for PostgreSQL databases that offers efficient wait event sampling without adding overhead, making it suitable for environments using versions 14 and above. It operates solely with SQL and PL/pgSQL, eliminating the need for additional C extensions or shared libraries, which ensures compatibility across diverse platforms like RDS, Cloud SQL, AlloyDB, Supabase, and Neon.
Key features of pg_ash include its ability to function without requiring database extensions, thereby simplifying deployment. It captures data every second from `pg_stat_activity` using a ring buffer mechanism that minimizes storage bloat and obviates the need for VACUUM operations. Compared to other tools like pg_wait_sampling, it provides more frequent sampling intervals, which enhances its utility in managed services such as Cloud SQL.
Functionally, pg_ash offers various analytical capabilities, including functions to assess wait events, queries, and session activities over specified time frames. It facilitates pattern identification through visualizations like bar charts and timeline charts. Moreover, it supports Large Language Model (LLM)-assisted investigations by chaining function calls for in-depth performance diagnostics.
The tool employs `pg_cron` for sub-minute scheduling, maintaining a high sampling frequency of one second while ensuring storage efficiency and minimal system resource usage. However, it is limited to primary databases due to its writing requirements, and under heavy loads, there may be gaps in sampling because of pg_cron's limitation to a single background worker. Furthermore, the query_map has an entry cap of 50,000 per partition before PostgreSQL version 16.
For users, installing and configuring pg_ash is straightforward, as it uses SQL scripts executable directly within PostgreSQL environments. It provides comprehensive functions for managing sampling processes, querying wait events, and analyzing particular queries or incidents. Licensed under Apache 2.0, pg_ash is a component of SAMO (self-driving Postgres), focusing on enhancing database performance monitoring and troubleshooting capabilities.
Keywords: #phi4, Active Session History, Apache 20, CPU, IO, LWLock, Lock, PL/pgSQL, PostgreSQL, SQL, lock contention, pg_ash, pg_stat_activity, query text, sampling rate, session history, wait event sampling, wait events
github.com 18 hours ago
|
193.
HN
Show HN: Scanward – Free domain security scanner (SSL, DNS, headers, email auth)
Scanward is a free domain security scanner designed to streamline DevOps processes by offering comprehensive checks across SSL, DNS hygiene, HTTP headers, and email authentication, all within a single scan that produces an A-F grade with detailed findings. It facilitates these assessments without requiring user signup for its public scanner, making it accessible and convenient for immediate use. The platform supports both one-time scans and continuous monitoring through account creation, providing alerts for changes like expiring certificates or altered grades, with up to ten domains free of charge.
Scanward's system is built on a robust tech stack featuring FastAPI, Celery, PostgreSQL, Redis, and Cloudflare Pages hosting via Next.js, ensuring a user-friendly experience without any installation. This is accomplished by leveraging publicly accessible data such as DNS queries, HTTP headers, and SSL handshakes for its scanning operations.
The service assesses six external security layers, including SSL/TLS certificate status, DNS configuration, HTTP headers, email security, and uptime, delivering a weighted score that communicates the domain's security posture clearly. Its setup process is designed to be quick and easy, requiring no server or DNS access; initial scans complete in under 60 seconds, with continuous rescans scheduled every six to twenty-four hours, accompanied by instant alerts on changes.
Targeted at teams without dedicated Security Operations Centers (SOC), including startups, SMBs, agencies, MSPs, solo sysadmins, and DevOps professionals, Scanward offers accessible security monitoring solutions at a cost-effective price point compared to enterprise tools. The pricing plans include a free tier for one domain with daily scans and email alerts, a Pro plan at $29/month supporting up to ten domains with bi-daily scans, and an Agency plan at $79/month for fifty domains, featuring more frequent scans and branded reports. Future enhancements for the Pro plan include Slack and PDF reports, while the Agency plan will soon offer multi-client dashboards and team accounts, underscoring Scanward's commitment to providing comprehensive security monitoring for teams lacking dedicated SOC resources.
Keywords: #phi4, A-F grade, Agency plan, Agency plan Keywords: Scanward, Celery, Cloudflare Pages, DNS, DevOps, DevOps engineers, FastAPI, HTTP headers, MSPs, Nextjs, PostgreSQL, Pro plan, Railway, Redis, SMBs, SOC, SPF/DKIM/DMARC, SSL, Scanward, agencies, continuous monitoring, domain security, email authentication, free tier, latency, pricing plans, startups, sysadmins, uptime
scanward.com 21 hours ago
|
195.
HN
Show HN: Spawn – Postgres migration/test build system with minijinja (not vibed)
"Spawn" is a PostgreSQL-focused database migration and build system designed to enhance the management of SQL components such as functions, views, triggers, and more. It offers innovative features like storing individual SQL elements in separate files, which facilitates precise Git diffs for tracking changes and simplifies test writing. The system uses `psql` for creating and applying migrations and supports golden file tests.
Key aspects include a modular component system that allows users to manage database logic effectively by separating components into distinct files. It also features a pinning mechanism similar to git, using lock files to maintain stable versions across updates. Spawn incorporates Minijinja templating, providing advanced capabilities with macros for generating complex SQL tasks.
The integrated testing framework supports ephemeral database copies and assertions based on diffs, enhancing the reliability of test scenarios. By addressing typical migration management challenges—such as cumbersome update processes, dependency issues, and version control complexities—"Spawn" treats database codebases as structured projects rather than just scripts to be executed.
Currently in public beta, Spawn's development roadmap includes features like rollback support, compatibility with other engines such as MySQL, multi-tenancy capabilities, drift detection, external data source integration, and a plugin system for additional customization. The project is actively seeking contributions and provides comprehensive documentation on its website. Users are informed about telemetry collection to aid in improvements, with an option to opt-out. Further details can be found on Spawn's GitHub page and documentation site.
Keywords: #phi4, CI/CD, Git diff, PostgreSQL, Spawn, build system, components, database, migration, minijinja, multi-tenancy, rollback support, templating, testing
github.com 22 hours ago
|
205.
HN
Pg_stat_ch: Observe Postgres from ClickHouse
The "pg_stat_ch" extension is an open-source initiative under the Apache 2.0 license created by ClickHouse to enhance analytics capabilities on PostgreSQL operations. It stands out from other extensions like pg_stat_statements and pg_tracing by providing comprehensive introspection and detailed analysis of all activities within a PostgreSQL cluster, such as queries, DDL commands, and errors. The extension captures each query execution event as a fixed-size entity (approximately 4.6KB) without initially including the full query plan. These events are temporarily stored in a shared-memory ring buffer by PostgreSQL backends before being periodically sent to ClickHouse using its native binary protocol with LZ4 compression, which minimizes performance impacts on PostgreSQL.
The architecture of pg_stat_ch is carefully optimized for efficiency and minimal disruption: it utilizes fixed-size events for predictable memory management, employs no-back-pressure techniques to avoid monitoring-induced performance degradation, reduces lock contention through the use of try-lock mechanisms and local batching, and leverages native protocol transfers for efficient data handling. Integration with ClickHouse allows this detailed analytics without additional storage overhead, evidenced by its high compression ratio.
Initial benchmarks reveal that pg_stat_ch introduces a modest performance impact, showing approximately 11% overhead in transactions per second (TPS) and latency under conditions of high concurrency, but significantly enhances lock contention management. Designed to operate within the unified ClickHouse-Postgres data stack, pg_stat_ch is tailored for delivering deep insights into PostgreSQL operations at scale. Ultimately, this extension offers a sophisticated toolset for monitoring and analyzing PostgreSQL clusters effectively while ensuring efficient use of resources across diverse query workloads and sizes.
Keywords: #phi4, ClickHouse, LWLock, Pg_stat_ch, PostgreSQL, analytics, compression, enqueue, events, extension, fixed-size, introspection, overhead, storage
clickhouse.com 23 hours ago
|
211.
HN
pg_background: Make Postgres do the long work (while your session stays light)
The `pg_background` extension enhances PostgreSQL by enabling the execution of SQL commands asynchronously through dedicated background worker processes. This feature allows long-running queries or maintenance tasks to be executed without maintaining an open client connection, ensuring non-blocking operations with clear lifecycle management (including launching, detaching, canceling, and waiting for results). Notable advantages include autonomous transactions that permit independent commit/rollback actions separate from the caller's transaction, as well as improved server-side observability through a v2 API that incorporates secure cookie-based identity features. These enhancements make `pg_background` particularly valuable in production settings where non-blocking operations, resource isolation, or "fire-and-forget" workflows are needed.
The most recent version (v1.8) of `pg_background` introduces several improvements such as operator-friendly features, strong random cookies for security, better memory management, and advanced observability tools like progress reporting and session statistics. To utilize this tool safely and effectively, it is recommended to use the v2 API for PID reuse protection, treat the `max_worker_processes` configuration as a capacity budget, design workflows with single-use result consumption in mind, and leverage new configuration options such as max worker limits and worker timeouts for greater control. Maintaining observability is also crucial to prevent unexpected issues. Overall, `pg_background` provides a streamlined approach for asynchronous SQL execution within PostgreSQL, enhancing both robustness and efficiency without the need for external job systems.
Keywords: #phi4, PostgreSQL, asynchronous execution, autonomous transactions, background workers, compatibility, max_worker_processes, non-blocking operations, resource isolation, server-side observability, transaction scope, v2 API, worker processes
vibhorkumar.wordpress.com a day ago
|
218.
HN
Show HN: FolioDoc – I built a tool to stop chasing clients for documents
FolioDoc is an innovative tool designed to simplify the process of collecting documents from clients for accountants and HR professionals, eliminating the need for manual follow-ups via email. It offers a streamlined approach where recipients are provided with a secure magic link that allows them to upload files effortlessly without creating an account. Central to its operation are SHA-256 hashed links, which enhance security alongside features such as automatic reminders, ClamAV virus scanning, and GDPR compliance, ensuring privacy with no tracking involved. The platform ensures robust data protection through TLS encryption, multi-layer file validation, rate limiting, and comprehensive audit trails. Additionally, FolioDoc offers customization options for branding and is built using a stack comprising Django, DRF, Next.js 14, Celery, Redis, PostgreSQL, all running on an EC2 instance managed by Docker Compose. Developed in Switzerland over several months, the tool includes a free tier and actively seeks user feedback on its recipient portal to enhance usability.
Keywords: #phi4, Celery, ClamAV, DRF, Django, Docker Compose, EC2, FolioDoc, GDPR, HR, Nextjs, PostgreSQL, Redis, SHA-256, Switzerland, TLS, accountants, checklist, documents, feedback, free tier, magic link, recipients, server-rendered, upload portal, white-label
news.ycombinator.com a day ago
|
226.
HN
Polyglot – a Rust/WASM SQL transpilation library
Polyglot is a versatile library written in Rust and compiled to WebAssembly (WASM), aimed at resolving the challenges posed by SQL dialect fragmentation across 33 different database systems like PostgreSQL, BigQuery, and Snowflake. It offers seamless transpilation of SQL queries between these supported dialects directly within a browser environment, eliminating the need for server communication. Core functionalities include parsing SQL strings into fully-typed Abstract Syntax Trees (AST), generating SQL from AST nodes, formatting SQL with proper indentation, and validating SQL for both syntax and semantic errors. Additionally, it provides a Builder API that allows users to construct queries programmatically using a fluent interface, which supports complex query features.
The library comprises a central Rust crate applicable in Rust projects or as a Wasm module for JavaScript environments, complemented by a TypeScript SDK for web and Node.js applications. Polyglot's wide-ranging capabilities make it suitable for various use cases such as database migration, multi-cloud analytics, SQL formatting and linting, query analysis, and educational tools. It can be integrated into browser-based editors, CI/CD pipelines, or ORM systems due to its robust parsing and generation functionalities. Supporting multiple environments including browsers, servers, and command-line interfaces, Polyglot invites community participation in its open-source development hosted on GitHub.
Keywords: #phi4, AST, BigQuery, CI/CD, ORMs, Polyglot, PostgreSQL, Rust, SDK, SQL, Snowflake, TypeScript, WASM, WebAssembly, analysis, browser, builder API, data tools, dialects, educational tools, formatting, generate, lineage, linting, migration, multi-database, notebooks, parse, playground, query construction, transpilation, validate
tobilg.com a day ago
|
230.
HN
OpenClaw Auditable Platform
TaskForge is an orchestration platform specifically developed for the OpenClaw project, emphasizing secure and auditable agent orchestration through sandboxed execution within Docker containers. It employs capability-based security to ensure that any new capabilities added require human approval before being integrated into a rebuilt Docker image, thereby enforcing minimal initial permissions for each agent while ensuring rigorous auditing.
The system supports multi-provider LLM routing, facilitating interactions with various large language models such as Ollama, Gemini, Anthropic, and OpenAI through a unified proxy. TaskForge maintains comprehensive audit trails that log every interaction with these models, capturing request/response data and token usage. Its architecture incorporates Temporal workflows to ensure durable execution of tasks, allowing for pausing and resuming processes based on approval requirements.
Key features include sandboxed Docker-in-Docker container execution, capability gating requiring explicit human approvals for additional packages or tools, and the deployment of agents as applications accessible via specific ports. For setup, TaskForge necessitates Docker 24+ with Compose v1 and at least 16GB RAM. Developers can clone the repository, set environment variables in a `.env` file, and initiate services using `make up`. Verification of service functionality is achieved through `make health`, while task creation and execution are facilitated via a UI for approvals or APIs/front-end interfaces.
The architecture comprises ten distinct services such as FastAPI control plane, image builder, Temporal workflows, PostgreSQL database, and Docker Registry. Comprehensive documentation, including data flow diagrams and security models, supports understanding of the system's design. Development and deployment are streamlined through Makefile commands that assist in building, starting, stopping, scaling, and logging services.
TaskForge is developed by Roman Pawel Klis, a senior AI solutions expert focusing on manufacturing and R&D, highlighting its emphasis on secure deployment and robust auditing capabilities for enterprise-level AI applications. The project is copyrighted under Klis from 2025-2026, with licensing details available in the LICENSE file.
Keywords: #phi4, API Key, Agent Orchestration, Anthropic, Audit Trail, Auditable, Compose, Container, Deployment, Docker, Environment Variables, FastAPI, Gemini, Generative AI, Human-in-the-loop, Image Rebuilds, LLM Routing, Multi-provider, Ollama, OpenAI, OpenClaw, PostgreSQL, Sandbox, Security, TaskForge, Troubleshooting, Workflows
github.com a day ago
|
250.
HN
Show HN: Pg-typesafe – Strongly typed queries for PostgreSQL and TypeScript
Pg-Typesafe is a TypeScript tool designed for PostgreSQL, offering strong typing capabilities to simplify handling SQL queries by automatically generating corresponding TypeScript types. This tool addresses the challenges associated with manually managing types in TypeScript, especially given its robust type system and inconsistencies like integer deserialization. Key features of Pg-Typesafe include automatic generation of TypeScript types for query parameters and results, working without runtime dependencies or added verbosity, and seamless integration with existing PostgreSQL client setups to ensure full type safety. Users begin by installing the tool via npm, generating a `defs.gen.ts` file containing project-specific types, and casting their Pool to `TypesafePool` to enable typed queries.
Pg-Typesafe is limited to typing constant SQL queries, not dynamic ones, as this limitation improves both query analysis security and performance. It also includes configuration options through a `pg-typesafe.config.ts` file for setting connection strings and other preferences, such as transforming BIGINTs into JavaScript BigInts or contextually typing JSONB columns.
While acknowledging the existence of alternatives, Pg-Typesafe is particularly advantageous in TypeScript environments by reducing manual type definitions and catching potential bugs early through static typing. This makes it a valuable tool for developers seeking enhanced type safety and efficiency when working with PostgreSQL databases in TypeScript projects.
Keywords: #phi4, BIGINTs, JSONB columns, Pg-typesafe, PostgreSQL, SQL injections, TypeScript, TypesafePoolClient, bigint conversion, node-pg, pg-typesafeconfigts, queries, type propagation, types
github.com a day ago
https://hackage.haskell.org/package/postgresql-typed-0. 23 hours ago
https://github.com/porsager/postgres 22 hours ago
https://joist-orm.io/ 18 hours ago
https://github.com/halcyonnouveau/clorinde/?tab=re 3 hours ago
https://github.com/kristiandupont/kanel 3 hours ago
https://github.com/n-e/pg-typesafe?tab=readme-ov-file#t 3 hours ago
https://learn.microsoft.com/en-us/dotnet/fsharp&#x 3 hours ago
https://fsprojects.github.io/SQLProvider/ 3 hours ago
https://github.com/Zaid-Ajaj/Npgsql.FSharp 3 hours ago
https://github.com/manifold-systems/manifold/blob& 3 hours ago
|
271.
HN
Hybrid Search in PostgreSQL: The Missing Manual
"Hybrid Search in PostgreSQL: The Missing Manual" by James Blackwood-Sewell delves into enhancing PostgreSQL's search capabilities through advanced extensions like ParadeDB and pgvector. Traditional full-text search in PostgreSQL is limited by its lack of global corpus awareness, but hybrid search addresses these shortcomings by merging lexical precision with semantic understanding.
ParadeDB introduces BM25 scoring to overcome the context limitations of native ranking functions by considering term frequency, inverse document frequency, and document length normalization, providing a refined relevance score. It simplifies integration into PostgreSQL through features such as native indexing, match disjunction, and optimization techniques. Meanwhile, vector similarity search augments semantic understanding by leveraging embeddings to relate concepts that may not have exact matching terms within documents.
The pgvector extension supports efficient similarity queries by enabling vector operations directly within PostgreSQL. Hybrid search integrates these methods using Reciprocal Rank Fusion (RRF), which amalgamates BM25 and vector search rankings without the need for score normalization. This approach highlights document relevance across systems, allowing additional factors like popularity or recency to refine results according to specific business needs.
This framework offers a comprehensive solution within PostgreSQL itself, eliminating reliance on external dependencies while maintaining consistency and transparency in ranking logic, thereby supporting sophisticated search strategies directly in the database.
Keywords: #phi4, BM25, Hybrid Search, ParadeDB, PostgreSQL, RRF (Reciprocal Rank Fusion), embeddings, extensions, full-text search, lexical search, pgvector, relevance ranking, semantic understanding, vector similarity
www.paradedb.com a day ago
|
300.
HN
Show HN: Diesel-guard adds custom checks via Rhai for Postgres migrations
Diesel-guard is a tool designed to ensure safer PostgreSQL migrations for production environments. It identifies potentially harmful operations within SQL migration files and suggests safer alternatives. Key features include the detection of table-locking operations, compatibility with Diesel and SQLx frameworks, and customizable checks using the Rhai scripting language. The tool addresses several critical operations:
1. **Adding Columns:** In PostgreSQL versions before 11, adding a column with a default value can lead to significant downtime due to exclusive locks. A safer method involves first adding the column without a default, then backfilling data separately, and finally setting the default for new rows only.
2. **Dropping Columns/Tables:** Directly dropping columns or tables results in locks that block other operations. The recommended approach is to separate application logic changes from migration tasks by marking a column unused before removal.
3. **Index Operations:** Dropping or creating indexes without `CONCURRENTLY` causes exclusive table locks. Using concurrent methods allows for ongoing database operations and prevents blocking.
4. **Data Types & Primary Keys:** Short integer primary keys can quickly exhaust, so using BIGINT is advised. Altering column types should be done in a multi-step approach to minimize downtime.
5. **Renaming Operations:** Renaming tables or columns requires staging to prevent immediate disruption of application instances.
6. **JSON and Timestamp Handling:** `jsonb` is preferred over `json` for performance, and `TIMESTAMPTZ` over `TIMESTAMP` to handle time zones effectively.
Diesel-guard can be installed via `cargo install diesel-guard` and checked using commands like `diesel-guard check migrations/2024_01_01_create_users/up.sql`. It supports JSON output for CI/CD integration, including GitHub Actions, to automate checks on pull requests.
The tool is also available as a pre-built action (`ayarotsky/diesel-guard`) in GitHub Actions, which can automatically install the Diesel Guard CLI and check migration files during pull requests. This installation method allows users to specify specific versions or always use the latest version for updates.
Configuration involves setting up a `diesel-guard.toml` file at the project root, where users specify the migration framework, migrations to skip based on timestamps, checks for down migrations, directories containing custom Rhai scripts for additional checks, and other options. Diesel Guard includes built-in checks against common PostgreSQL migration hazards and allows users to create their own using Rhai scripts that analyze SQL statement Abstract Syntax Trees (ASTs) for violations.
The tool executes once per SQL statement, providing detailed reports on violations as strings or arrays of maps detailing operations, problems, and safe alternatives. It offers debugging aids like `dump-ast` for script development and handles runtime errors gracefully, allowing safety-assured blocks to bypass checks when operations are verified as safe by developers. Inspired by strong_migrations, Diesel Guard aims to enhance migration safety within CI/CD pipelines and is open to contributions under an MIT license.
Keywords: #phi4, AST, CI/CD, Diesel, Diesel-guard, PostgreSQL, Rhai, Rust, SQLx, actions, alternatives, checks, configuration, constraints, custom checks, extensions, framework, functions, indexes, installation, jobs, lock, migrations, operations, pull_request, safety-assured, tables, triggers, violations
github.com a day ago
|
315.
HN
PgDog: Connection pooler, load balancer and sharder for PostgreSQL
PgDog is an open-source network proxy designed specifically for PostgreSQL applications, functioning as a connection pooler, load balancer, and database sharder to boost performance and scalability under heavy traffic conditions without requiring changes to application code or database structure. Key features include reliable sharding that accommodates cross-database queries with in-transit calculations for aggregates such as count(), min(), and max(). It supports seamless multi-tuple inserts and sharding key mutations, even when using ORMs like Prisma and Sequelize. PgDog facilitates atomic and synchronized cross-shard writes through a two-phase commit process without necessitating ORM modifications. The tool provides omnisharded tables enabling atomic operations on replicated data across shards and a unique sequence generation system for producing cross-shard integers similar to PostgreSQL's native sequences. It offers built-in resharding capabilities that significantly improve the efficiency of moving data between shards compared to previous methods. PgDog also manages write traffic during failovers, supports managed Postgres services, and can handle complex SQL queries without needing additional load balancers like HAProxy. Additionally, its connection pooling feature automatically handles unfinished transactions and partially sent queries to maintain database connections and minimize CPU usage. Continually evolving, particularly in supporting cross-shard queries, PgDog emphasizes configurability, ease of integration, and community engagement, inviting contributions and feedback while providing comprehensive documentation for users.
Keywords: #phi4, PgDog, PostgreSQL, Python/Ruby/Go apps, UUIDs, aggregate functions, atomic writes, connection pooler, cross-shard queries, database sharding, failover, load balancer, logical replication, multi-tuple inserts, network proxy, query rewriting, resharding, sharder, transaction rollback, two-phase commit
news.ycombinator.com a day ago
|
356.
HN
We replaced ClickHouse with PostgreSQL and got faster
Reflag enhanced its data layer by transitioning from ClickHouse to PostgreSQL, leading to substantial improvements in site performance and search efficiency. Initially using ClickHouse because of pre-existing event ingestion pipelines, the database struggled with selective, real-time queries, which became crucial as targeting grew more important. By adopting PostgreSQL, Reflag optimized its schema for indexed lookups and relational filtering, cutting query times from several seconds to under 200 milliseconds and halving infrastructure costs by approximately 50%. The ingestion pipeline was also re-engineered to directly feed into PostgreSQL, simplifying data flow, reducing operational complexity, and enhancing debugging and iteration processes. This strategic shift not only streamlined system architecture but significantly boosted performance, better aligning with Reflag’s evolving requirements.
Keywords: #phi4, ClickHouse, PostgreSQL, Reflag, analytical queries, architectural decisions, data layer, flags, indexed lookups, infrastructure costs, ingestion layer, ingestion pipeline, operational overhead, performance improvements, relational queries, search, segments, targeting
reflag.com a day ago
|
359.
HN
The Next Version of Curling IO
Curling IO is upgrading its technical infrastructure to bolster reliability and performance while maintaining the current user experience for club managers and curlers. Originally built on Rails since 2019, the platform now requires a new tech stack to accommodate anticipated growth and technological progressions. The key upgrades involve adopting Gleam, a type-safe functional language that compiles to Erlang (BEAM VM) for backend operations and JavaScript for frontend development. This transition promises several benefits: compile-time error checking, massive concurrency, predictable code, shared types between client and server, and effective management in large-scale systems. Additionally, new AI Agent APIs will be introduced to enable interactions with AI assistants like ChatGPT without altering existing web interfaces.
The platform's database will shift from PostgreSQL to SQLite for reasons including operational simplicity, cost savings, improved in-process speed, and isolated databases. Contrary to initial assumptions, this switch is projected to significantly enhance performance metrics such as concurrent connections, data volume management, and throughput during peak usage.
A meticulous transition plan ensures continuity of service: Version 2 will remain active while the new Version 3 is developed and rigorously tested before a seamless migration. Initially, Curling IO will begin with a single server setup, scaling up resources as necessary to postpone complexities associated with distributed systems until required.
This upgrade represents the initial phase of the Curling IO Foundation series, which will be further expanded in future posts detailing additional enhancements like bilingual support.
Keywords: #phi4, AI Agent APIs, BEAM VM, Concurrency, Curling IO, Developer Onboarding, Functional Patterns, Gleam, Infrastructure, PostgreSQL, PostgreSQL Keywords: Curling IO, Rails, SQLite, Technical Upgrades, Type Safety, Version 3
curling.io a day ago
|
360.
HN
Show HN: I turn scattered feedback into a prioritized roadmap in 5 min
Fran, a full-stack developer, has developed Plaudera to address the challenge of efficiently managing and prioritizing customer feedback for Software as a Service (SaaS) products scattered across various channels. By introducing a public feedback board equipped with voting functionalities and an embeddable widget, Plaudera consolidates user suggestions in one place, allowing businesses to identify and prioritize feature requests without manual intervention. The tool leverages AI-powered duplicate detection to combine similar feedback automatically, ensuring streamlined prioritization based on the most popular ideas among users. Built using Next.js, TypeScript, and PostgreSQL, Plaudera is designed to help developers concentrate on enhancing aspects of their products that align with user demands. Fran offers early access to the tool for $49, inviting inquiries about its technology and his experiences in building indie SaaS solutions. Notably, he uses Plaudera internally to manage feedback for his own projects, demonstrating the tool's practical application and value.
Keywords: #phi4, AI deduplication, AI-powered duplicate detection, Feedback, Nextjs, Plaudera, PostgreSQL, SaaS products, Slack DMs, Twitter, TypeScript, customer feedback tool, duplicates, early growth mode, emails, embeddable, feature request board, feature requests, feedback loop, full-stack dev, lifetime deals, lightweight, public feedback board, roadmap, script tag, support tickets, user priorities, voting, widget
plaudera.com a day ago
|
400.
HN
What would a "permissions-first ORM" look like? Looking for spec feedback
`superapp`, a "permissions-first ORM," is designed to securely connect frontends to various databases, ensuring data protection through automatic authentication and row-level permissions enforcement. It consists of three key packages: `@superapp/backend`, which establishes connections to databases like Postgres, MySQL, SQLite, or CSV using DuckDB while managing authentication and enforcing permissions; `@superapp/db`, a Drizzle ORM client that incorporates permission checks via the backend's engine; and `@superapp/auth`, responsible for handling client-side authentication with better-auth as the default option, offering session management and UI components. The system operates by authenticating users through JSON Web Tokens (JWTs) and authorizing requests by injecting user-specific WHERE clauses to scope data per individual. On the backend, permission-filtered SQL queries are executed to maintain security. Developers configure server settings for database connections and permissions, with the ORM ensuring type safety and enforcing permissions without needing explicit authorization logic in the frontend. This architecture allows safe client-side use of Drizzle ORM but recommends backend execution to enhance control over caching and error handling.
Keywords: #phi4, CSV, Drizzle ORM, DuckDB, Hono, JWT, MySQL, ORM, PostgreSQL, React hooks, SQL, SQLite, authentication, authorization, client-side, data layer, database, enforcement, filtering, frontend, introspection, middleware, permissions, roles, schema, scoping, server-side, session management, type safety, user roles
typescript-superapp.bunnytech.app a day ago
https://zenstack.dev a day ago
https://zenstack.dev/blog/database-to-mcp a day ago
https://zenstack.dev/blog/ai-agen a day ago
|
407.
HN
Show HN: ActorRise - Find the perfect monologue less than 20 seconds
ActorRise is an innovative platform designed specifically for actors seeking quick access to short audition monologues under 20 seconds, created by a combination of an actor's insights and a software engineer's expertise. The platform addresses the limitations found in existing platforms like Backstage, which typically offer limited choices with many overdone pieces, by providing a comprehensive database featuring over 8,600 monologues from more than 172 plays. Unlike traditional methods that rely on predefined filters, ActorRise employs AI-powered semantic search technology, allowing users to find suitable monologues simply by describing what they need in natural language terms. Built using modern technologies including Next.js for the frontend, FastAPI and PostgreSQL with pgvector for backend operations, and LangChain for its AI capabilities, ActorRise aims to significantly streamline the audition preparation process. The platform offers a free tier while actively seeking feedback from the Hacker News community on both its search functionality and technical framework. Future developments plan to introduce additional tools such as ScenePartner and CraftCoach to further enhance users' experience in preparing for auditions.
Keywords: #phi4, AI, AI search, ActorRise, Backstage, CraftCoach, CraftCoach Keywords: ActorRise, FastAPI, HN, HN community, LangChain, Nextjs, PostgreSQL, ScenePartner, audition, community, database, engineer, feedback, free, free tier, monologue, pgvector, plays, search, semantic, semantic search, software, software engineer, stack, tech, tech stack, tier
www.actorrise.com a day ago
|
427.
HN
A/B Testing Your RAG Pipeline
The article outlines strategies for optimizing Retrieval-Augmented Generation (RAG) pipelines through A/B testing of different components when querying PDF documents. It starts by acknowledging a basic RAG system's functionality using semantic chunking and cosine similarity-based retrieval but argues that performance can be significantly enhanced by experimenting with various approaches.
Key elements in this optimization process include the baseline system, which utilizes Python FastAPI, PostgreSQL with pgvector, PyMuPDF for parsing, OpenAI embeddings, and Claude for generation. The article emphasizes an A/B testing approach to swap out chunking strategies, embedding models, or retrieval methods to identify performance improvements. This is facilitated by using a workflow involving Claude Code agent teams and Graphite for easy management of different versions.
Specific variants tested include fixed-size versus semantic chunking, local parsing with PyMuPDF against Reducto's cloud-based parser, and comparing cosine similarity with hybrid search (cosine + BM25). Additionally, the benefits of using a reranker like Cohere or a cross-encoder are analyzed, along with comparing embedding models such as text-embedding-3-small and text-embedding-3-large. Determining the optimal number of top results, known as top_k sizing, is also explored.
The article stresses evaluating configurations through metrics like retrieval precision, recall, answer faithfulness, latency, and costs using offline evaluation suites. The workflow's efficiency allows for rapid testing by creating separate pull requests (PRs) for each variant, facilitating easy implementation and assessment without extensive rebuilding. While the example focuses on a legal document Q&A system, these strategies are broadly applicable to various RAG applications.
In conclusion, the article highlights that building an optimal RAG pipeline requires iterative experimentation tailored to specific datasets and use cases. This workflow supports efficient exploration of different configurations to achieve desired performance outcomes in terms of precision, speed, and cost-effectiveness.
Keywords: #phi4, A/B Testing, API, Answer Generation, BM25, Chunking, Claude, Claude Code, Cohere, Corpus Size, Cosine Similarity, Cross-Encoder, Document Parsing, Domain-specific Queries Keywords: A/B Testing, Embedding Generator, Embedding Model, Evaluation Suite, FastAPI, Fixed-size Chunking, Graphite, Hybrid Search, Infrastructure, Ingestion Pipeline, Latency, Legal Documents, Legal PDFs, OpenAI, Over-fetch, PDFs, PostgreSQL, Precision, PyMuPDF, Query Complexity, RAG Pipeline, React, Recall, Reducto, Reranker Interface, Reranking, Retrieval, Retrieval Strategy, Semantic Analysis, Semantic Chunking, Storage Impact, TanStack Router, Token Cost, Top_k, pgvector
www.rasha.me 2 days ago
|
442.
HN
PostgreSQL Bloat Is a Feature, Not a Bug
Bloat in PostgreSQL arises from its Multi-Version Concurrency Control (MVCC) system, where updates result in new row versions and deletions mark rows as obsolete rather than removing them immediately. This accumulation of "dead tuples" leads to increased disk usage and potentially slower query performance, as more I/O operations are needed for PostgreSQL to access live data amid these obsolete entries within fixed-size pages. Bloat affects both tables and indexes, where deleted or updated row information remains until actions like REINDEXing or VACUUM FULL are performed. While standard VACUUM reclaims dead tuple space without reducing file size, VACUUM FULL also reduces the size but requires table locking.
PostgreSQL's autovacuum feature automatically cleans up dead tuples once they exceed specific thresholds, such as 20% of live tuples, to manage bloat efficiently. However, under heavy write loads or when long-running transactions delay tuple cleanup, autovacuum may not be sufficient, necessitating tuning of its settings for optimal performance. Regular maintenance through VACUUM and careful autovacuum parameter adjustment is crucial in high-traffic environments to mitigate the impact of bloat, ensuring efficient disk usage and maintaining query performance. Proper management practices are essential to sustain PostgreSQL's operation without significant overhead or performance degradation due to excessive dead tuple accumulation.
Keywords: #phi4, MVCC, PostgreSQL, REINDEX, VACUUM, autovacuum, bloat, dead space, disk usage, index bloat, pages, performance, transactions, tuples
rogerwelin.github.io 2 days ago
|
462.
HN
Show HN: Deploy a DuckLake data lakehouse on Hetzner for under €10/mo
The document serves as a comprehensive guide for deploying DuckLake, an integrated data lakehouse solution that combines PostgreSQL, Hetzner Object Storage (S3-compatible), and DuckDB as its query engine on Hetzner Cloud. The deployment is designed to be cost-effective, costing under €10 per month. The setup process involves using OpenTofu, a fork of Terraform, for infrastructure management, along with PyInfra for server configuration, and automates tasks through a Makefile.
To begin the setup, users must ensure they have specific prerequisites: OpenTofu, the Python package manager uv, DuckDB version 1.3.0 or newer, and a Hetzner Cloud account with API tokens and Object Storage access keys. The environment configuration involves copying a sample file and updating it with necessary credentials, which are then sourced for use in subsequent steps. Additionally, SSH key generation is required unless already available.
Deployment commences by initializing OpenTofu using the command `make init`, followed by deploying the infrastructure and configuring the server with `make all`. The DuckDB connection process involves sourcing the environment file and running initialization scripts to start queries.
Regarding security, the initial setup allows open PostgreSQL connections from any IP address for simplicity but advises restricting this access in production environments. SSH protection is enhanced through fail2ban to safeguard against unauthorized attempts.
The cost breakdown includes a VPS (cx33) priced at approximately €5.49 per month, providing 4 vCPUs, 8GB of RAM, and an 80GB NVMe SSD. Object Storage incurs a charge of about €3.50 per terabyte per month, making the total expenditure for storing up to 1TB of data less than €10 per month.
The guide suggests using a cx33 server as the preferred option due to frequent stock shortages of the more economical cx23 model. However, it also provides guidance on modifying the Terraform configuration if users opt to use the cx23 instead, offering flexibility in resource allocation according to user needs and availability.
Keywords: #phi4, API token, DuckDB, DuckLake, Hetzner, IPv4, OpenTofu, PostgreSQL, PyInfra, S3 storage, SSH keys, Terraform, VPS, automation, cloud account, cost, cx33, data lakehouse, deployment, fail2ban, firewall, infrastructure, init script, initialization, makefile, metadata, object storage, query engine, security, server provisioning
github.com 2 days ago
|
495.
HN
Show HN: API router that picks the cheapest model that fits each query
Komilion is an API router designed to optimize costs when selecting AI models for processing queries by serving as a drop-in replacement for the OpenAI SDK. It efficiently routes requests using regex patterns and lightweight classifiers across roughly 390 models categorized into three tiers—Frugal, Balanced, and Premium—to balance quality against cost considerations. The system features automatic failover capabilities that ensure continuous operation even if one model provider becomes unavailable.
Komilion's logic is benchmark-driven rather than machine learning-based, which simplifies debugging processes. A notable example of its cost-saving potential was demonstrated in a customer support bot scenario where expenses dropped significantly from approximately $250 per month to about $40 by strategically routing queries instead of relying on expensive models like Opus 4.6. The architecture relies on Next.js for front-end development, Vercel and Neon PostgreSQL for backend services, and OpenRouter, with hosting costs around $20 monthly.
The system provides three operational modes: Neo Mode, which autonomously selects the most suitable model for tasks such as prototyping; Pinned Mode, where users can choose specific models to ensure consistent output quality while automatically upgrading to newer versions without downtime or code changes; and a budget-aware routing mode that dynamically adjusts based on user-defined tiers. These features offer flexibility and control over AI workloads, facilitating efficient handling of diverse tasks with automatic updates. Further insights into Komilion’s architecture and benchmarking results can be found in the supplementary materials linked in the original document.
Keywords: #phi4, API router, Komilion, LLM classifier, Neo Mode, Neon, Nextjs, OpenAI SDK, OpenRouter, PostgreSQL, Vercel, auto-upgrade, automatic failover, autonomous selection, benchmark-driven, budget-aware routing, cost optimization, model routing, multi-model orchestration, pinned mode, quality-cost tradeoff, regex classifier, zero downtime
www.komilion.com 2 days ago
|
505.
HN
Show HN: Queryline – One app for SQL and Firestore with a command palette
Queryline is an innovative app designed to enhance database management by integrating support for both SQL (PostgreSQL, MySQL, SQLite) and Firestore into a single interface. Developed using Tauri 2 with technologies like Rust, Vue 3, and the Monaco Editor, it offers a keyboard-centric workflow that includes shortcuts such as CMD+K for efficient navigation between connections, tables, and recent queries. Its standout features encompass virtual scrolling for handling large datasets smoothly, native operating system integration to securely manage credentials via keychain, and multi-format export options including CSV, JSON, and SQL. The app addresses the inefficiencies of switching between different database tools by providing a unified experience across both SQL and NoSQL databases. Created out of Samko's frustration with existing solutions, Queryline aims to deliver an efficient tool that supports diverse databases while ensuring high performance and minimal footprint. Feedback for the application is encouraged through its GitHub page or official website.
Keywords: #phi4, CMD+K, DuckDB, Firebase, Firestore, Monaco Editor, MySQL, NoSQL, OS keychain, PostgreSQL, Queryline, Rust, SQL, SQLite, Tauri, Vue 3, export formats, multi-database support, query history, schema browser, virtual scrolling
queryline.dev 2 days ago
|
528.
HN
Show HN: KanVibe – Kanban board that auto-tracks AI agents via hooks
KanVibe is a self-hosted Kanban board specifically designed to manage AI coding tasks involving multiple Claude Code agents across different branches. It streamlines the process by eliminating the need for manual checks of tmux sessions, offering browser-based terminals and automatic task status updates via Claude Code Hooks. Key features include live terminal views on each task card using xterm.js, allowing users to monitor outputs directly in their browsers without attaching to tmux sessions. The system automates task management by moving tasks across statuses like PROGRESS, PENDING, and REVIEW based on hooks, obviating the need for manual updates.
The setup of KanVibe necessitates Node.js 22 or higher, as well as either tmux or zellij, with Docker also being required. Users can quickly start by cloning the repository, configuring environment variables, and executing a `bash start.sh` script to install and launch the server. The workflow involves registering projects via scanning local git repositories, creating tasks on the Kanban board that automatically initiate necessary resources, managing task statuses through manual drag-and-drop or automated transitions, and selecting from various terminal pane layouts.
Additional features of KanVibe include multi-project filtering with real-time updates facilitated by WebSocket, support for tmux/zellij multiplexers, SSH remote terminals, and internationalization in Korean, English, and Chinese. The technical infrastructure comprises a frontend/backend built on Next.js 16, React 19, and TypeScript; PostgreSQL managed through TypeORM as the database; Tailwind CSS v4 for styling; terminal management via xterm.js coupled with WebSocket and node-pty; drag-and-drop functionality using @hello-pangea/dnd; and internationalization support via next-intl. The KanVibe software is distributed under the AGPL-3.0 license, which permits open-source use and modification but prohibits commercial SaaS distribution without sharing source code modifications.
Keywords: #phi4, AGPL-30 license, AI agents, Claude Code, Docker, Git worktree automation, KanVibe, Kanban board, Nextjs, PostgreSQL, React, browser terminals, hooks integration, internationalization, pane layouts, task management, terminal sessions, tmux, zellij
github.com 2 days ago
|
537.
HN
SQL vs. NoSQL vs. Columnar: Choosing the Right Database for Your Go Service
The article evaluates four databases—PostgreSQL, MongoDB, Cassandra, and ClickHouse—to determine their effectiveness in managing 100 million user events with real-time analytics requirements. PostgreSQL is highlighted for its strong ACID compliance and reliability but faces challenges with large-scale analytics queries, especially on time-series data. Conversely, MongoDB offers a flexible document-oriented schema yet underperforms in aggregations involving extensive datasets. Cassandra is noted for its superior write scalability and straightforward key-value access patterns but lacks the capability to efficiently handle complex queries and aggregations without considerable application-level intervention.
Among these options, ClickHouse stands out as the most suitable choice for analytics tasks due to its columnar storage format, which provides exceptional query performance and high compression rates for large data volumes. The study recommends a hybrid architecture combining PostgreSQL for transactional data management, MongoDB for storing flexible documents, and ClickHouse for conducting analytics. This setup is integrated using Kafka for event streaming. Ultimately, the article underscores that selecting the appropriate database should be based on specific workload needs rather than defaulting to one-size-fits-all solutions.
Keywords: #phi4, 2dsphere Indexes, ACID Transactions, Aggregations, Analytics Queries, Append-only Workloads, Automatic Partitioning, BRIN Indexes, Batch Insert, CDC (Change Data Capture), Cassandra, ClickHouse, Columnar, Compression, Data Migration, Data Modeling, Database, Deduplication, Document-oriented, Event Processor, Go Service, Hybrid Architecture, Hypertables, JSON Parsing, Kafka, Kafka Writer, Materialized Views, MongoDB, Monthly Cost, Multi-datacenter Replication, NoSQL, Partition Key, Performance Metrics, PostgreSQL, Query Time, Real-time Analytics, SQL, Storage Size, Time-series Data, TimescaleDB, Transactional Data, Write Speed, Write Throughput
skoredin.pro 2 days ago
|
538.
HN
Show HN: Logtide – Open-source log management and SIEM for European SMBs
Logtide is an open-source platform designed to manage logs and provide Security Information and Event Management (SIEM) services specifically for European small and medium-sized businesses (SMBs). The platform focuses on GDPR compliance, offering self-hosting capabilities with data residency options to adhere to European regulations. It utilizes a straightforward technology stack consisting of SvelteKit, Fastify, PostgreSQL combined with TimescaleDB, and BullMQ, all deployed using Docker Compose for simplicity and transparency.
Key features include multi-tenancy, PII masking, OpenTelemetry tracing, anomaly detection, real-time streaming, alert correlation, along with support for Sigma rules and the MITRE ATT&CK framework. Logtide provides a pluggable storage architecture, defaulting to TimescaleDB for high compression rates and future plans to integrate ClickHouse for enhanced scalability in enterprise settings.
The platform is licensed under AGPLv3 to prevent unauthorized use by cloud vendors while respecting European data sovereignty laws, though this licensing decision has sparked debate. Currently in the alpha phase, Logtide offers a free cloud version aimed at early adopters who can contribute feedback, having rebranded from its original name, LogWard, due to trademark issues.
Logtide presents itself as an alternative to established platforms like Datadog, Splunk, and ELK by emphasizing GDPR compliance and simplicity, eliminating the need for ElasticSearch management. It supports deployment via Docker and Kubernetes with available Helm charts and offers SDKs in multiple programming languages (Node.js, Python, Go, PHP, Kotlin, C#/.NET) to facilitate easy integration.
The platform features include real-time log viewing through Server-Sent Events, robust search capabilities, automatic log retention policies, and comprehensive security-focused incident management. Additionally, Logtide supports Sigma rules for threat detection and provides a SIEM dashboard complete with incident management, MITRE ATT&CK mapping, and the ability to export reports in PDF format.
Overall, Logtide emphasizes performance, maintainability, and compliance by leveraging modern technologies such as SvelteKit, Fastify, PostgreSQL+TimescaleDB, Redis, and Docker. Its comprehensive toolset supports effective log management and threat detection while prioritizing security within a user-friendly framework.
Keywords: #phi4, AGPLv3, Docker Compose, Docker images, Fastify, Fluent Bit, GDPR compliance, Helm chart, Kubernetes, Logtide, MITRE ATT&CK, OpenTelemetry, PII masking, PostgreSQL, Redis, SDKs, SIEM, Sigma rules, SvelteKit, TimescaleDB, alert correlation, alerting, anomaly detection, cloud provider protection, data sovereignty, distributed tracing, event correlation, incident management, integrations, log ingestion, log management, multi-tenancy, real-time streaming, retention policy, security dashboard, threat detection
github.com 2 days ago
|
549.
HN
Show HN: Rivestack – Managed PostgreSQL with pgvector, $29/mo
Rivestack presents itself as an affordable managed PostgreSQL service specifically designed to support advanced applications like Retrieval-Augmented Generation (RAG) and semantic search by incorporating pre-installed pgvector. It distinguishes itself in the market by providing cost-effective, dedicated instances in EU and US-East regions, ensuring reliable performance through features such as automated backups, robust monitoring systems, and high availability facilitated by Hetzner's infrastructure, Patroni for HA, and pgBackRest for backups. With a $29/month plan, Rivestack boasts impressive benchmarks: it handles up to 2,000 queries per second (QPS) with latency under 4ms for 10,000 vectors, and 252 QPS with 32ms latency while maintaining 98% recall for 1 million vectors. Additionally, the service extends a free tier aimed at testing purposes. Rivestack targets developers in this niche area by inviting community feedback, positioning itself as an alternative to more expensive or resource-shared solutions currently available in the market.
Keywords: #phi4, EU regions, HA, HN, Hetzner infrastructure, Managed PostgreSQL, Patroni, QPS, RAG, Rivestack, US-East, automated backups, benchmarks, free tier, latency, monitoring, pgBackRest, pgvector, recall, semantic search
www.rivestack.io 2 days ago
|
553.
HN
TaskForge – OpenClaw in contained permission based platform
TaskForge is an advanced orchestration platform designed to enhance the OpenClaw project by offering a secure environment for executing AI agents within isolated Docker containers. It prioritizes capability-based security, requiring agents to acquire additional permissions through human validation. Key features include sandboxed execution in Docker-in-Docker environments, where agents start with limited privileges and request new capabilities like network access or package installations via a human-mediated process. Upon approval, these capabilities are integrated into immutable Docker images. TaskForge supports multiple language model providers, including Ollama, Gemini, Anthropic, and OpenAI, through a unified proxy system while maintaining a comprehensive audit trail of all interactions with language models.
The platform facilitates the deployment of agent applications on specific ports and offers a straightforward setup process requiring Docker 24+ and an LLM provider. The architecture comprises a detailed system design featuring a ten-service Docker Compose topology, data flow diagrams, and various service functionalities like API management, image creation, workflow execution, and dashboard access. For local development and troubleshooting, TaskForge provides structured directories for components such as the control plane, image builder, and agent executor, with PostgreSQL 15 serving as its database system. Developed by Roman Pawel Klis, TaskForge is open-source under a specific license, encouraging discussions about its use in organizational contexts.
Keywords: #phi4, AI Solutions, API Key, Anthropic, Audit Trail, Container Config, Data Science, Deployment, Docker, FastAPI, Gemini, Human-in-the-loop, Image Rebuilds, Multi-provider, Ollama, OpenAI, OpenClaw, PostgreSQL, Routing, Sandbox, Security, TaskForge, Troubleshooting, Workflows
github.com 2 days ago
|
590.
HN
Show HN: Mindweave – AI-powered personal knowledge hub with semantic search
Mindweave is an AI-driven personal knowledge hub designed to streamline the process of capturing, organizing, and retrieving various types of digital content such as notes, links, and files. By consolidating information typically scattered across multiple applications into a single, cohesive platform, Mindweave addresses common challenges associated with losing saved data. Central to its functionality is the Semantic Search feature, which enhances content discoverability by understanding user intent through meaning-based searches using pgvector cosine similarity and Gemini embeddings. Additionally, AI Auto-Tagging automatically categorizes content upon saving it, minimizing manual effort and encouraging broader adoption. Another innovative feature is Knowledge Q&A, which utilizes Retrieval-Augmented Generation (RAG) to deliver contextually relevant answers based on the user's stored content.
Technologically, Mindweave incorporates a variety of modern tools: Next.js 15 for its frontend framework, PostgreSQL with pgvector for database management and semantic search capabilities, Google’s Gemini for embedding generation, Drizzle ORM for object-relational mapping, Auth.js v5 for authentication processes, and TailwindCSS for styling. The platform is deployed on Cloud Run, emphasizing a seamless user experience through its robust search functionalities and intuitive organization features. User feedback on aspects like the semantic search UX and RAG implementation is actively sought to refine these offerings. Mindweave can be accessed at www.mindweave.space, with its source code available for review or contribution on GitHub.
Keywords: #phi4, AI-powered, Authjs, Cloud Run, Drizzle ORM, Google Gemini, Knowledge Q&A, Mindweave, Nextjs, PostgreSQL, RAG, Tailwind, UX, auto-tagging, bookmarks, capture, cosine similarity, embeddings, links, notes, personal knowledge hub, pgvector, semantic search
www.mindweave.space 2 days ago
|
598.
HN
Show HN: MultiWA - Open-source self-hosted WhatsApp API Gateway
MultiWA is an open-source, self-hosted gateway designed to integrate multiple WhatsApp numbers through a single API, catering primarily to businesses and developers seeking reliable messaging solutions independent of cloud-based dependencies. It emphasizes full operational control with features like multi-session management for unlimited accounts, pluggable engine adapters (such as whatsapp-web.js and Baileys), and a unified messaging API that supports real-time WebSocket updates and JWT authentication.
The platform includes an advanced admin dashboard developed using Next.js 14, offering functionalities such as a live chat interface, analytics, an audit trail, and a visual flow builder for automation. It further enhances capabilities with AI integration via OpenAI or Google AI for knowledge bases, scheduled messages, broadcast abilities, webhooks, API keys, SDKs in TypeScript, Python, and PHP, push notifications, and SMTP email alerts.
For enterprise use, MultiWA incorporates security features like Helmet, CSP, rate limiting, encryption at rest, and GDPR compliance. The deployment is facilitated through Docker with health checks, while background processing is managed via BullMQ. The technical architecture comprises Nginx for SSL/Proxy, Next.js for the admin interface, NestJS/Fastify for the API, WhatsApp engine adapters (whatsapp-web.js, Baileys), a Worker using BullMQ, PostgreSQL database, and Redis cache.
The technical stack includes NestJS 10 + Fastify for the API, Next.js 14 + Tailwind CSS for the admin UI, PostgreSQL 16 with Prisma ORM for the database, Redis 7 with BullMQ for caching/queuing, JWT for authentication, and Socket.IO for real-time communication. Users can start MultiWA either through Docker for production or via local development processes.
Comprehensive API documentation is accessible via Swagger UI, while official SDKs are available in TypeScript/Node.js, Python, and PHP to ease integration. Contributions are welcome under the MIT License, with detailed guidelines provided. The project's structure comprises various applications (API backend, admin dashboard, worker), shared packages (utilities, database schema, WhatsApp adapters, SDKs), a plugins directory, Dockerfiles, documentation, and deployment scripts.
Overall, MultiWA offers a robust, self-hosted solution for businesses requiring comprehensive WhatsApp integration capabilities without cloud reliance.
Keywords: #phi4, AI, Automation, BullMQ, Docker, Enterprise-ready, GDPR, GitHub Actions, JWT Authentication, Multi-engine, MultiWA, Nextjs, Open-source, PHP, Plugin System, PostgreSQL, Python, Redis, SDKs, Security, Self-hosted, TypeScript, WebSocket, Webhooks, WhatsApp API Gateway
github.com 2 days ago
|
609.
HN
Deploy OpenClaw on your own server in just one click
AgentDaddie provides a user-friendly solution for deploying the OpenClaw AI platform on private servers with a single-click deployment process that bypasses technical complexities. By integrating with DigitalOcean, it automates server provisioning and software installation tasks such as setting up Docker and configuring secure local API keys, which enhances security by avoiding third-party key storage. The service offers ease of use through seamless account connections for swift deployment while ensuring users maintain full control over customization and scalability of the OpenClaw platform.
Key features include support for various AI models like GPT from OpenAI and Anthropic’s Claude, with integration capabilities for communication via Telegram. AgentDaddie uses a robust tech stack comprising Next.js, React, TypeScript, Drizzle ORM, PostgreSQL, Better Auth, SWR, Axios, and Cloudflare adapters to deliver secure and responsive application deployment. Developers can utilize provided scripts for local development, database management, and deployment processes, including Cloudflare integrations.
The project is open-source under the MIT License, promoting transparency and encouraging community contributions. It offers comprehensive guidance on running locally, managing databases, handling migrations, and configuring Hyperdrive for cloud-based database connections. Ultimately, AgentDaddie streamlines AI infrastructure management by automating complex deployment processes while prioritizing data security and user control.
Keywords: #phi4, AI models, API keys, AgentDaddie, Cloudflare, DigitalOcean, Docker, Drizzle ORM, Hyperdrive, Nextjs, OAuth, OpenClaw, PostgreSQL, Telegram, deployment, migrations, open source, security, server
github.com 2 days ago
|
610.
HN
ZFS Quickstart
ZFS is a comprehensive file system adept at managing volume discovery, RAID configurations, and network access. While some sources recommend disabling PostgreSQL's full_page_writes due to ZFS's consistency features, this practice lacks support from the developers of PostgreSQL, as it can cause corruption when data is replicated onto non-ZFS volumes. For installation on Rocky or Alma Linux, users must install necessary packages from the EPEL repository and ensure proper configuration and loading of ZFS modules at system startup. Memory management is crucial for systems running demanding applications like databases; this involves configuring settings to limit ARC memory usage. On FreeBSD, enabling ZFS in `/etc/rc.conf` and setting a GUID partition map are recommended practices. Key ZFS commands include creating zpools and volumes without needing partition tables and using scheduled scripts for managing snapshots effectively. Filesystems can be shared over NFS networks by setting the `sharenfs` property, enabling seamless sharing within specific network ranges. For virtual machines, ZFS supports direct attachment of virtual disk images (zvols) to platforms like KVM or Bhyve. Additionally, following a system reinstallation, all existing zpools can be automatically imported using the command `zpool import -a`.
Keywords: #phi4, ARC memory, Alma Linux, Bhyve, FreeBSD, GUID partition map, KVM, NFS export, PostgreSQL, RAID, Rocky Linux, ZFS, file system, full_page_writes, network access, snapshot management, virtual machines, zpool, zvol
eradman.com 2 days ago
|
617.
HN
Show HN: SyncFlow – Privacy-Focused SMS/MMS Sync Between Android, Mac, and Web
SyncFlow is a privacy-centric application designed for synchronizing SMS/MMS messages from Android devices to Mac computers and web browsers without relying on major tech cloud services like Google Messages. The app operates via a dedicated server that uses Node.js/Express for the API and PostgreSQL as its database, prioritizing user data privacy. Key features include end-to-end encryption using the Signal Protocol to secure message transmission, WebRTC support for video/audio calls, and MMS attachments stored on Cloudflare R2 through presigned URLs. Real-time messaging is powered by WebSocket technology, while Firebase Auth handles user identity separately from their messages.
The application was developed with Kotlin for Android development, Swift for Mac integration, Next.js for web functionalities, and Express paired with PostgreSQL for server-side operations. SyncFlow's capabilities extend to reading and sending SMS/MMS, full synchronization of contacts and call histories, video/audio calling, file transfers between devices, spam filtering, and scheduling messages. It offers a free usage tier allowing up to 200 messages per month, with paid plans available to remove message limits. The developers invite feedback specifically on the end-to-end encryption implementation and MMS synchronization method.
Keywords: #phi4, Android, Architecture Feedback, Audio Calling, Cloudflare R2, E2EE, Express, File Transfer, Firebase Auth, Kotlin, Mac, Nextjs, Nodejs, PostgreSQL, Privacy-Focused, SMS/MMS Sync, Scheduled Messages, Signal Protocol, Spam Filtering, Swift, SyncFlow, Video Calling, Web, WebRTC, WebSocket
sfweb.app 2 days ago
|
639.
HN
Scaling Django to 10M active users on a single VM
In this reflective article, the author discusses Photoroom's journey in scaling their Django Rest Framework (DRF) system to accommodate over 10 million monthly active users and manage around 500 queries per second on a single VM. Initially relying on Firebase for authentication, the team faced challenges such as constraints on anonymous user tracking and regional availability issues, particularly in China. To efficiently handle substantial data traffic, Photoroom extensively utilized Cloudflare's caching services but encountered difficulties like cache-related crashes.
For database performance enhancement, they adopted several strategies including the use of managed PostgreSQL databases, disabling long-running queries, optimizing pagination techniques, consulting with a DB tuning agency, and implementing regular backups for recovery purposes. To improve cross-platform developer collaboration (iOS, Android, web), they transitioned from Notion specs to OpenAPI documentation.
The author candidly shares past missteps, such as accidental self-DDoS incidents and the inadvertent deletion of vital app content during cleanup operations. However, proactive steps like early integration of an Application Performance Management (APM) tool and the adoption of concurrent indexes helped mitigate potential downtime issues. As Photoroom approaches a milestone of 200 million mobile downloads, future challenges are identified as updating deployment procedures, reworking storage methodologies, and enhancing support for real-time collaboration.
Concluding with a forward-looking perspective, the author seeks to recruit a Django backend engineer equipped with extensive experience in Django to address these upcoming challenges. This call emphasizes the critical need for expertise in this area as they continue to scale and evolve their platform.
Keywords: #phi4, APM, Celery, Cloudflare, DDOS, DRF, Django, Firebase, GenAI, Kubernetes, OpenAPI, Photoroom, Postgresql, VM, real-time collaboration, scaling
eliot.blog 3 days ago
|
654.
HN
Show HN: Endlessh Fisher – Turn SSH tarpit bots into collectible fish
Endlessh Fisher is a gamified tool designed to interface with the endlessh-go honeypot system, turning data from trapped SSH bots into an interactive fishing game. This innovative approach utilizes InfluxDB to gather metrics from endlessh-go, presenting them through a dynamic and engaging dashboard that visualizes these bots as fish species in an aquarium. The application categorizes bots into 12 distinct species based on the duration they remain trapped, ranging from common Plankton to the mythic Leviathan.
A standout feature is its ability to support multiple endlessh instances, each represented as unique "fishing ponds" with customizable themes. The tool enhances user engagement through an achievement system comprising over 50 achievements across eight categories and introduces daily challenges along with collectible treasures that offer real-world security insights. Additionally, Endlessh Fisher provides optional IP intelligence using services like Shodan InternetDB and AbuseIPDB to deliver detailed insights into open ports, abuse scores, and vulnerabilities.
The tool also incorporates a global tracking system for trapped bots via a world map and competitive leaderboards, encouraging users to track records and high scores. A fish encyclopedia acts as a Pokédex-style tracker for the various species of fish. Bilingual support in German and English ensures broader accessibility, while privacy-focused design principles ensure GDPR compliance through default IP data hashing.
Deployment is streamlined using Docker and Docker Compose, with options for both simple setups and advanced configurations like Traefik with Blue-Green deployment. The technical stack includes Django 6.0 for backend development, supported by frameworks such as Django REST Framework, Celery, and Redis, while the frontend leverages HTMX, Alpine.js, and Tailwind CSS. PostgreSQL and InfluxDB serve as the primary data sources.
Endlessh Fisher provides numerous read-only API endpoints, facilitating health checks, dashboard statistics, bot catches, server lists, fish species information, daily statistics, country statistics, and achievement status tracking. The project is open-source, licensed under MIT, and was developed by DarkWolfCave.
Keywords: #phi4, Celery, Django, Docker, Endlessh, HTMX, IP intelligence, InfluxDB, PostgreSQL, REST API, SSH, Traefik, blue-green deployment, gamification, honeypot, leaderboard, tarpit, visualization
github.com 3 days ago
https://github.com/shizunge/endlessh-go 3 days ago
|
686.
HN
Show HN: Respectlytics – Open-source, privacy-first mobile analytics (MIT+AGPL)
Respectlytics is an open-source mobile analytics platform emphasizing privacy and minimal data collection, designed with the "Return of Avoidance" (ROA) principle to align with privacy regulations. Its privacy-centric design collects only five essential fields per event: `event_name`, `session_id`, `timestamp`, `platform`, and `country`, using IP addresses solely for transient country lookups before discarding them to prevent storage of personal data. The platform's open-source nature allows users to review the code for compliance, offering SDKs (Swift, Flutter, React Native, Kotlin) under the MIT license and a self-hosted analytics server with Django and PostgreSQL under AGPL-3.0.
Respectlytics minimizes data by anonymizing session IDs stored only in RAM, which rotate every two hours or upon app restarts, intentionally disabling multi-session tracking. It supports easy self-hosting via Docker Compose without requiring additional services like ClickHouse or Kafka, though a managed cloud version is available for those preferring not to handle hosting. Technical setup requires Python 3.12+, PostgreSQL 14+, and Node.js 18+ with configuration via environment variables for custom settings such as debug mode and SSL requirements.
The platform includes optional GeoIP integration using the MaxMind GeoLite2 database for approximate location tracking, a comprehensive API reference, and official SDKs across multiple mobile platforms. Administration is facilitated through an accessible web-based admin panel with optional two-factor authentication. Community involvement is encouraged via contribution guides requiring a Contributor License Agreement (CLA). While the community edition is under AGPL-3.0 allowing free use and modification, commercial licenses are offered for organizations needing managed infrastructure and priority support through Respectlytics Cloud, positioning it as an ideal choice for developers prioritizing compliance and data minimization in mobile app development.
Keywords: #phi4, 2FA, AGPL-30, API reference, Docker, GDPR compliance, GeoIP, IP address, PostgreSQL, Respectlytics, SDKs, commercial licensing, contributor license agreement, country lookup, data minimization, data retention, mobile analytics, open-source, privacy-first, self-hosting, session-based
github.com 3 days ago
|
719.
HN
Show HN: Quoracle: Self-replicating multi-LLM-consensus agents (Elixir)
Quoracle is a sophisticated Phoenix LiveView application aimed at enabling hierarchical agent systems that make decisions through consensus among multiple language models (LLMs). Its main innovation lies in its ability to query several LLMs and execute actions only when there's agreement, which enhances decision-making reliability compared to single-model approaches. The system supports recursive spawning of child agents, inheriting context and constraints from parent agents, facilitating complex hierarchical operations. Additionally, Quoracle offers real-time observability through a browser dashboard that provides live updates on tasks, logs, and agent interactions, powered by PostgreSQL and Phoenix LiveView.
Key features include the multi-model consensus approach for decision-making, where multiple LLMs are queried to achieve agreement before execution, enhancing decision reliability. The application supports recursive hierarchies allowing child agents to inherit contexts from parent agents, which is crucial for maintaining operational consistency across different levels of the hierarchy. Security is a focus, with encryption of API keys at rest and scrapping secrets from outputs prior to processing by LLMs.
Setting up Quoracle requires Elixir (>= 1.18) with OTP (>= 27), PostgreSQL (>= 14), and libvips for certain features. Deployment options include development setups, Docker, or using a release tarball, requiring specific environment variables such as `CLOAK_ENCRYPTION_KEY` for encryption.
Usage involves configuring model roles and credentials to define capabilities and access to LLM providers, creating profiles that specify participating models in consensus and permissible actions, and defining tasks with particular agent identities, roles, skills, cognitive styles, output formats, and delegation strategies. Despite its robust core functionalities, Quoracle is still in beta, lacking user authentication and facing increased API costs due to the multi-model consensus approach. It's intended for single-user or trusted networks without extensive sandboxing for shell commands and network isolation. The project invites contributions and operates under the GNU Affero General Public License v3.0.
Keywords: #phi4, API keys, Docker, Elixir, OTP, Phoenix LiveView, PostgreSQL, PubSub isolation, PubSub isolation Keywords: Quoracle, Quoracle, agent, agent orchestration, capability groups, consensus, encryption, multi-LLM, multi-LLM consensus, orchestration, recursive agents
github.com 3 days ago
|
734.
HN
Show HN: LaunchFast – Ship your Next.js SaaS in days, not months
LaunchFast is a Next.js-based SaaS boilerplate aimed at accelerating the development of subscription-based web applications, enabling rapid deployment in days instead of months by incorporating essential features such as authentication, payments, AI integration, and email functionality. It utilizes NextAuth v5 for Google and GitHub OAuth with Prisma persistence to handle user authentication efficiently. The payment system is powered by Stripe, facilitating subscription management through checkout processes, billing portals, and webhook handling. For artificial intelligence capabilities, LaunchFast provides access to the Anthropic Claude API, featuring session protection and rate limiting. Transactional email services are integrated via Resend for sending automated messages like welcome emails.
LaunchFast prioritizes security with robust measures including authentication, input validation, rate limiting, and type checking. It offers a pricing structure that includes a Standard Plan at $79, a Pro Plan at $119, and a Complete Bundle offering additional products for $99. Developers can quickly start by cloning the repository, installing dependencies, setting environment variables, running database migrations, and initiating the development server. The project is structured into components, APIs, authentication, payments, email utilities, and layout files to streamline development processes.
The boilerplate also provides comprehensive configuration and deployment guides covering setup for authentication, databases, payment systems, AI, and emails, with optional monitoring using Sentry for error tracking. Built with a modern tech stack that includes Next.js 15, TypeScript 5, Tailwind CSS v4, Prisma with PostgreSQL, Stripe, Anthropic Claude API, and Resend, LaunchFast is available under the MIT License, making it suitable for both personal and commercial use. This all-in-one solution is designed to empower developers in launching secure, feature-rich SaaS applications quickly using contemporary web technologies.
Keywords: #phi4, AI, Anthropic Claude, Authentication, Boilerplate, Dashboard, Deployment, Email, License, Middleware, Monitoring, NextAuthjs, Nextjs, Payments, PostgreSQL, Prisma, Resend, SaaS, Sentry, Stripe, Tailwind CSS, TypeScript, Vercel, Webhooks
github.com 3 days ago
|
743.
HN
Mskql – AI driven adversarial development
Mskql is an AI-driven in-memory SQL engine developed entirely by artificial intelligence agents, written in C for enhanced speed and efficiency. It outperforms PostgreSQL in several performance metrics, such as batch latency and concurrent throughput, achieved with a minimalistic codebase of approximately 24,000 lines without external dependencies, where each subsystem operates within a single file. Mskql supports the PostgreSQL wire protocol version 3, ensuring compatibility with tools like psql, pgAdmin, and DBeaver, and can run locally on port 5433 or interactively in a browser via WebAssembly, providing a server-free SQL query experience directly in web browsers.
The development of Mskql utilized an innovative iterative process involving three AI agents: a challenger creating adversarial SQL tests, a reviewer spotting code quality issues, and a writer addressing these issues until all over 960 test cases were successfully passed. This approach underscores the engine’s reliability and robustness achieved without human intervention in coding or testing phases.
Mskql demonstrates notable performance improvements over PostgreSQL, particularly excelling in aggregate batch processing and distinct batch operations with significantly faster execution times. Users can engage with its capabilities through a web-based interface that supports experimentation with various SQL commands, ranging from basic data manipulation to complex queries like recursive common table expressions (CTEs).
For developers interested in exploring or contributing to Mskql’s architecture, the source code is available on GitHub, offering insights into its unique development methodology and compact system design.
Keywords: #phi4, AI, C language, CREATE TABLE, Common Table Expressions, Date/Time Arithmetic, GROUP BY, INSERT INTO, JOINs, PostgreSQL, SELECT, SQL engine, UPSERT, WebAssembly, adversarial development, agents, aggregation, benchmark, database, mskql, parser, performance, query executor, storage, test cases, window functions, wire protocol
martinsk.github.io 4 days ago
|
750.
HN
Scalable PaaS (Automated Docker+Nginx) – a.k.a. Heroku on Steroids
CapRover offers a user-friendly platform designed to streamline the deployment of applications and databases for various programming languages such as NodeJS, Python, PHP, Ruby, among others. It simplifies this process by eliminating the need for in-depth knowledge of Docker or Nginx, thanks to its intuitive interface. Utilizing Docker Swarm for containerization and Nginx for load balancing, CapRover also provides free SSL certificates through LetsEncrypt. Accessible via both command-line interface (CLI) and web graphical user interface (GUI), it significantly reduces the time required to set up servers and cuts down on hosting costs compared to platforms like Heroku. Notably, CapRover allows users freedom from vendor lock-in; if needed, applications can be removed without disrupting functionality. The system requires minimal technical skills—primarily the ability to copy and paste commands or configurations. More details about this project, which benefits from community contributions and financial support, are available on its website at [CapRover.com](https://CapRover.com).
Keywords: #phi4, Automation, CLI, CapRover, Deployment, Docker, GUI, Go, Heroku, Hetzner, Load-balancing, MariaDB, MongoDB, MySQL, Nginx, NodeJS, PHP, PaaS, PostgreSQL, Python, Ruby, SSL, Server Setup, Webserver, WordPress
github.com 4 days ago
|
761.
HN
Every App Needs Auth / Ory Helps / This Template Fixes It
The ORY Starter Template facilitates the integration of comprehensive authentication mechanisms into applications by leveraging the ORY Stack—specifically, ORY Kratos for user identity management and ORY Hydra as an OAuth 2.0 and OpenID Connect provider. This Docker-based template streamlines setting up these functionalities locally, offering a structured approach to implementing secure user authentication and token issuance workflows.
Key components of this setup include a PostgreSQL database configured automatically for data storage, with ORY Kratos handling the intricacies of user login and registration processes. Meanwhile, ORY Hydra takes charge of OAuth 2.0 and OpenID Connect protocols by issuing JSON Web Tokens (JWTs) after authentication tasks are delegated to Kratos. The Next.js application integrates a custom user interface using shadcn/ui components, functioning as both an OAuth client and server-side token handler through the Backend-for-Frontend (BFF) pattern.
Architecturally, the system orchestrates OAuth2/OIDC flows where users start interactions managed by Hydra, with Kratos managing authentication tasks. Post-authentication, users return to Hydra for consent and JWT issuance, ensuring secure storage of tokens within httpOnly cookies.
The template outlines various services and endpoints: ORY Hydra offers public and admin APIs with pre-configured OAuth client settings, while the Next.js application provides routes for login, registration, consent, and logout operations. For development and testing, PostgreSQL is accessible via PgAdmin, and Mailslurper supports email testing environments. The system includes a test script to confirm service health and configuration.
Configurations are managed through respective config files; Hydra’s settings reside in `hydra-config/config.yaml`, with automatic OAuth client creation at startup facilitated by an initialization script. Similarly, Kratos configurations allow for environmental customization regarding identity management features. Overall, this template simplifies embedding robust authentication systems using Dockerized ORY components and Next.js architecture into applications efficiently.
Keywords: #phi4, API, Authentication, BFF, Configuration, Consent Flow, Database, Docker, Email Testing, Hydra, Identity Management, JWT, Kratos, Mailslurper, Nextjs, OAuth Client, OAuth2, ORY, OpenID Connect, PostgreSQL, Session Management, Setup Script, Testing, Tokens, UI Components
github.com 4 days ago
|
773.
HN
Pg_stat_ch: Postgres extension to ship every PG metric to ClickHouse
The article presents "pg_stat_ch," an open-source extension for PostgreSQL designed to stream detailed query execution metrics into ClickHouse, enhancing analytical capabilities without significantly impacting performance. This tool captures data on all query types within a PostgreSQL cluster, including SELECTs, INSERTs, DDL statements, and failed queries. Key features include using fixed-size events (~4.6KB) to maintain predictable memory usage and efficient processing. Data is streamed with minimal impact through shared-memory ring buffers, atomic operations, and background workers that handle data batching and LZ4 compression. The extension avoids back-pressure scenarios that could degrade query latency during high loads or network issues by minimizing lock contention via a tiered enqueue path with local buffering. Communication between PostgreSQL and ClickHouse uses the clickhouse-cpp library for efficient columnar encoding and LZ4 compression. This integration allows for capturing detailed analytics in PostgreSQL without performance degradation, making it ideal for large-scale operations. The extension aims to provide valuable monitoring and troubleshooting tools within ClickHouse Cloud environments by leveraging ClickHouse's analytical strengths. Performance benchmarks indicate a modest overhead of approximately 2% CPU usage, with optimized lock management techniques reducing contention effects on transaction per second (TPS).
Keywords: #phi4, ClickHouse, LZ4 compression, Pg_stat_ch, PostgreSQL, analytics, back-pressure, fixed-size events, introspection, lock contention, managed service, metrics, native protocol, per-query events, ring buffer, storage costs, streaming, telemetry
clickhouse.com 4 days ago
|
779.
HN
What's your biggest database deployment pain point?
DRM-CLI is a command-line tool designed for managing database deployments across multiple platforms like Oracle, PostgreSQL, and SQL Server. It provides a unified interface that simplifies deploying databases by consolidating various tasks such as tracking deployment history, ensuring environmental consistency, and accommodating platform-specific differences. Key benefits of DRM-CLI include its resilient deployment strategies with built-in retry mechanisms to handle transient failures, support for parallel execution enabling simultaneous deployments, and comprehensive tracking and security features utilizing SQLite or JSON databases for deployment records and encryption for sensitive data. The tool is cross-platform compatible, functioning on both Windows and Linux systems.
To begin using DRM-CLI, users need prerequisites like Python 3.8+, pip, Git, and specific database drivers such as `cx_Oracle` for Oracle deployments. Integration with other database tools including Flyway, Liquibase, and sqlpackage enhances its deployment capabilities. Installation involves cloning the repository from GitHub and executing a tailored Python script for either Windows or Linux environments. Configuration options are available through JSON or SQLite formats, with secure encryption key setups.
DRM-CLI features include multi-platform deployment support, source control integration, intelligent retry mechanisms, parallel execution, dry run mode, secure data encryption, and alignment modes ensuring database states match intended configurations. Users can customize deployment settings via configuration files. The open-source project encourages community contributions for improvements like additional platform support and internationalization, offering issue reporting or help through GitHub Issues and Discussions. Further documentation is accessible on the official website, with DRM-CLI licensed under MIT. Created by seasoned database administrators, it addresses common challenges in data deployments.
Keywords: #phi4, CLI tool, DRM-CLI, Flyway, JSON, Liquibase, Oracle, PostgreSQL, Python, SQL Server, SQLite, configuration, cross-platform support, data releases, database deployment, encryption, environment variables, integration, multi-platform, open-source, open-source Comma-separated Keywords: DRM-CLI, open-source Comma-separated List: DRM-CLI, open-source Extracted Keywords: DRM-CLI, open-source Final Answer: DRM-CLI, open-source Final Keywords: DRM-CLI, open-source Final List: DRM-CLI, open-source Keywords: DRM-CLI, open-source Simplified Keywords: DRM-CLI, parallel execution, platforms, retry mechanism, source control, sqlpackage, troubleshooting
github.com 4 days ago
|
838.
HN
Pg_stat_ch: A PostgreSQL extension that exports every metric to ClickHouse
pg_stat_ch is an open-source extension developed to enhance the observability and analytics of PostgreSQL deployments by streaming detailed query execution metrics directly to ClickHouse, part of ClickHouse's managed Postgres effort. This tool captures a broad range of event data, such as SELECTs, INSERTs, DDLs, and failed queries, through fixed-size events (approximately 4.6KB) that are batched and efficiently transmitted using ClickHouse’s native protocol with LZ4 compression. Its architecture prioritizes predictable memory usage by employing fixed-size events to avoid variable-length allocations and minimize impact on PostgreSQL performance through a high-performance ring buffer with minimal lock contention, akin to UDP-based monitoring systems where data loss is tolerable for better performance.
The extension hooks into PostgreSQL's execution lifecycle to gather detailed metrics that are processed in ClickHouse. Pre-aggregated via materialized views, this setup allows immediate analytical queries without overburdening PostgreSQL. Performance tests on a high-concurrency TPC-B setup revealed an overhead of around 11% in transactions per second (TPS) due primarily to lock contention, which was reduced from approximately 24% to 11% by optimizing the enqueue path. The CPU overhead remains low at about 2%, underscoring its efficient design. In terms of storage, ClickHouse achieves a high compression ratio (~83:1), making it cost-effective even for high query volumes like 10K QPS, with estimated monthly costs under $100. Consequently, pg_stat_ch offers enterprises deep insights into PostgreSQL operations without significant performance compromise.
Keywords: #phi4, ClickHouse, LWLock, Pg_stat_ch, PostgreSQL, analytics, compression, extension, fixed-size events, introspection, managed service, metrics, native protocol, ring buffer, storage costs, telemetry
clickhouse.com 4 days ago
|
839.
HN
Show HN: SQL-tap – Real-time SQL traffic viewer for PostgreSQL and MySQL
SQL-tap is an innovative tool designed for real-time monitoring of SQL queries in PostgreSQL and MySQL databases without requiring any changes to the existing application code. It functions as a transparent proxy that intercepts database queries and presents them through an interactive terminal user interface (TUI), enabling users to inspect, run `EXPLAIN`, or analyze these queries directly within this interface. The tool captures SQL traffic in real-time and supports executing `EXPLAIN` and `EXPLAIN ANALYZE` commands on the captured queries without altering application code.
SQL-tap is equipped with a gRPC interface that facilitates communication between its proxy daemon, known as `sql-tapd`, and the TUI client, `sql-tap`. Users can install SQL-tap through various methods: via Homebrew from `mickamy/tap`, using Go commands as per documentation, by building from source after cloning from GitHub, or through Docker images pre-configured for PostgreSQL and MySQL. To use SQL-tap, users need to start the proxy daemon on a specific port to capture database traffic, redirect their application's database connection to this port, and then launch the TUI client to visualize SQL queries in real-time.
The usage involves configuring `sql-tapd` with several flags for driver, listen address, upstream database settings, and gRPC server address. Additionally, setting an environment variable like `DATABASE_URL` is necessary to enable EXPLAIN functionality. The `sql-tap` client connects via a gRPC address to display the SQL traffic. It supports various keybindings that allow navigation, query inspection, transaction toggling, and execution analysis through different views such as list, inspector, and explain modes.
Licensed under the MIT License, SQL-tap offers broad usage and distribution rights. Its operation relies on parsing database wire protocols to capture queries transparently while maintaining seamless communication between applications and databases via gRPC streams.
Keywords: #phi4, Docker, EXPLAIN, MIT license, MySQL, PostgreSQL, SQL-tap, TUI client, commands, daemon, explain plan, gRPC, installation, proxy, queries, real-time, terminal UI, traffic viewer, transactions, wire protocol
github.com 4 days ago
https://adaptive.live 4 days ago
https://dbfor.dev 4 days ago
https://github.com/circonus-labs/wirelatency 4 days ago
https://pgtap.org/ 4 days ago
https://eunomia.dev/tutorials/40-mysql/ 4 days ago
https://www.envoyproxy.io/docs/envoy/latest/c 4 days ago
https://www.envoyproxy.io/docs/envoy/latest/i 4 days ago
https://github.com/inconshreveable/sqltap 4 days ago
https://www.envoyproxy.io/docs/envoy/latest/c 4 days ago
https://www.cncf.io/blog/2020/08/13/envo 4 days ago
https://stackgres.io 4 days ago
|
880.
HN
Oracle vs. PostgreSQL – Row level and Column level security
The document provides a comparative analysis of row-level and column-level security features within Oracle and PostgreSQL databases, focusing on how these systems implement granular access controls. It explains that both DBMSs enable restrictions on user data interactions based on predefined policies, which determine the specific rows or columns users can view or manipulate. The comparison seeks to elucidate the strengths and limitations inherent in each system's approach to managing data security, offering insights into their effectiveness at safeguarding sensitive information by controlling access at a detailed level. This analysis aims to help stakeholders understand how each database management system addresses security requirements within its architecture.
Keywords: #phi4, Access Control, Column-level Security, Comparison, Data Protection, Database, HexaCluster, Oracle, PostgreSQL, Row-level Security, SQL Databases, Security Features, Technical Keywords
hexacluster.ai 5 days ago
|
887.
HN
Show HN: I built a self-hosted network video surveillance system
Ronin NVR is a self-hosted network video surveillance system designed to enhance privacy by addressing concerns associated with commercial security cameras. Developed from Synology Surveillance Station, it leverages technologies like FastAPI, React, PostgreSQL, and Docker for seamless orchestration of its components. The system supports up to 14 IP cameras, providing continuous 24/7 recording, live streaming capabilities, and machine learning (ML)-powered object detection. Key features include video handling through FFmpeg for HLS streaming and MP4 recording, intelligent activity tracking using YOLO11 with ONNX Runtime, and a tiered storage management system that supports automatic migration across hot, warm, and cold tiers, with an option to offload older recordings to S3. The architecture combines React for frontend development and Python for the backend, encompassing camera management, video streaming, and ML detection systems. While supporting GPU acceleration, the system can also run in CPU-only mode. It is currently accessible via a home VPN with basic user authentication, with plans to improve storage migration to S3 and security features. Deployment relies on Docker Compose to manage services like PostgreSQL, FastAPI backend, and Nginx frontend, with configuration options covering database settings, storage paths, encryption keys, and ML parameters. The project is released under the MIT license.
Keywords: #phi4, Docker, Docker Compose, Docker Compose Keywords: Self-hosted, FFmpeg, FastAPI, GPU acceleration, HLS streaming, IP cameras, JWT tokens, ML-powered detection, Network Video Surveillance, ONNX Runtime, PostgreSQL, RTSP, React, Self-hosted, Synology, Vision LLM integration, YOLO11, activity tracking, authentication, encryption, live view, playback system, security, storage management, tiered storage
github.com 5 days ago
|
898.
HN
Show HN: Pg_stat_ch, a Postgres extension to export every metric to ClickHouse
The `pg_stat_ch` extension for PostgreSQL facilitates the real-time export of detailed query telemetry data to ClickHouse, a columnar database management system. It captures extensive metrics on query execution, including timing, buffer usage, and CPU time, without aggregating them within PostgreSQL itself. This is achieved by utilizing PostgreSQL hooks to capture events stored in shared memory and exported through a background worker process to ClickHouse. The extension ensures minimal network I/O and non-blocking query execution even if the event queue overflows or ClickHouse becomes unavailable.
Key features of `pg_stat_ch` include support for all statement types, such as DML, DDL, utility statements, and error events identified by SQLSTATE codes. It offers advanced telemetry in PostgreSQL 15+ with Just-In-Time (JIT) instrumentation data like function count and optimization times, and collects parallel worker statistics in versions 18 and above.
Installation requires adding `pg_stat_ch` to the `shared_preload_libraries`, configuring ClickHouse schema either via provided scripts or manually using `clickhouse-client`, creating the extension within PostgreSQL, and setting various configurations through GUC variables for connection details, queue capacity, batch size, TLS usage, and logging level. Verification of installation is done by checking version and statistics with SQL functions such as `pg_stat_ch_version()` and `pg_stat_ch_stats()`.
The extension fully supports PostgreSQL versions 16, 17, and 18. For building and testing, prerequisites include tools like CMake, a compatible C++ compiler, PostgreSQL development headers, and the `clickhouse-cpp` library, with Mise or manual steps involving CMake commands being viable methods for setup. Licensed under Apache License 2.0, detailed instructions on usage, configuration, testing procedures, and troubleshooting can be found in accompanying documentation files.
Keywords: #phi4, ClickHouse, PostgreSQL, aggregation, configuration, data pipeline, error capture, exporter, extension, installation, metrics, pg_stat_ch, query instrumentation, real-time export, ring buffer, shared memory, telemetry, testing, troubleshooting
github.com 5 days ago
|
910.
HN
Building takes shorter than writing about it
Karo, an AI product manager, successfully developed a Valentine's Day-themed scratch card game in just 33 minutes using modern web development tools such as React + TypeScript for the front end, PostgreSQL for the database, and Node.js for the backend. This application allows users to interact with it by scratching six hearts over three days to discover prizes. Karo emphasizes how contemporary advancements in coding have streamlined the creation process, allowing for swift development without extensive debugging. Although designed as a temporary project rather than one for long-term use, this endeavor showcases the ease with which interactive and engaging applications can now be created using platforms like Replit.
Karo encourages readers of all technical backgrounds to embark on their own projects using these accessible tools, underscoring that coding is more approachable today. For those interested in exploring further, premium members have access to the full source code through StackShelf App, a platform aiming to enhance developers' work within its community. The article concludes by inviting individuals to share their projects with the PwA community for greater visibility and support, promoting an environment of shared growth and innovation.
Keywords: #phi4, AI, Drizzle ORM, Express, Framer Motion, Nodejs, PostgreSQL, Premium Members, React, Replit, StackShelf, Tailwind CSS, TypeScript, Valentine's Day, animations, community, confetti, database, engineering, gamification, product management, scalability, security audit, web app
karozieminski.substack.com 5 days ago
|
911.
HN
Pg_stat_ch: We built low-overhead Postgres metrics exporter to ClickHouse
The "pg_stat_ch" extension serves as an innovative open-source solution designed for PostgreSQL, facilitating low-overhead metric exportation to ClickHouse by capturing detailed event data from PostgreSQL clusters. These metrics include SELECT and INSERT statements, DDL changes, and even failed queries, all aimed at enhancing operational insights. This tool mirrors the analytical capabilities traditionally associated with ClickHouse's internal system tables, thus allowing users to analyze Postgres usage directly within the database—a feature that aligns seamlessly with ClickHouse’s managed Postgres initiative.
The extension is engineered with a streamlined architecture that minimizes resource consumption and ensures minimal impact on PostgreSQL performance. It employs fixed-size events (~4.6KB) stored in a shared-memory ring buffer, which are subsequently batched and transmitted to ClickHouse using LZ4 compression via the native binary protocol. This approach guarantees predictable memory usage and reduces lock contention. To maintain system efficiency, pg_stat_ch avoids back-pressure mechanisms during high loads by dropping events when buffers overflow or transmissions fail, thereby prioritizing performance over data completeness.
Integrating seamlessly with PostgreSQL, pg_stat_ch hooks into various execution points without disrupting other extensions like pg_stat_statements and auto_explain. Despite its comprehensive monitoring capabilities, the extension imposes a modest ~2% CPU overhead in high-concurrency scenarios, translating to about an 11% TPS/latency impact due to lock contention. On the ClickHouse side, data compression achieves an impressive ratio of approximately 83:1, significantly reducing storage requirements.
Supporting PostgreSQL versions 16 through 18 and licensed under Apache 2.0, pg_stat_ch provides essential insights into PostgreSQL operations with minimal overhead, making it an invaluable asset for managing extensive Postgres deployments within the ClickHouse ecosystem.
Keywords: #phi4, APM, CPU overhead, ClickHouse, LZ4 compression, PostgreSQL, TPS latency, analytics, background worker, contention amplification, enqueue lock, event streaming, extension, fixed-size events, flamegraph, introspection capability, low-overhead, managed service, materialized views, metrics exporter, native protocol, per-query events, profiling, query behavior, shared-memory ring buffer, storage costs, telemetry
clickhouse.com 5 days ago
|
915.
HN
Show HN: Wax – RAG in a single file (SQLite for AI memory)
Wax is a Swift-native memory solution designed for seamless integration of Retrieval-Augmented Generation (RAG) into applications, eliminating complex infrastructure setups by utilizing a crash-safe file format. Its key feature is single-file storage in an .mv2s format, which consolidates documents, embeddings, retrieval indices, metadata, and logs. Wax operates offline, deterministically, without requiring server or internet connectivity, ensuring reproducible results with consistent token budgeting. The solution excels in performance on Apple Silicon devices (M1 Pro), achieving sub-millisecond GPU vector search and fast memory access times due to its compatibility with Metal GPU features.
Wax stands out by offering advantages such as hybrid search capabilities that adapt queries using methods like BM25 and vectors, tiered memory compression for efficient context management, and deterministic retrieval ensuring consistent token usage. It ensures privacy by keeping data on-device without any network interactions. Compared to other systems like Chroma, Core Data + FAISS, and Pinecone, Wax offers unique benefits including offline capability, crash-safety, GPU acceleration, and being Swift-native.
Ideal use cases for Wax include AI assistants, offline-first applications with intensive search needs, privacy-sensitive products, research tools requiring reproducibility, and agent workflows needing a durable state. The solution requires Swift 6.2 and is compatible with iOS/macOS 26 or later on Apple platforms, with enhanced performance on Apple Silicon devices.
To get started with Wax, developers can add it to their projects via Package.swift using the provided GitHub URL, select appropriate memory types (Text, Photo, Video), and implement recall functionalities. Contributions are encouraged by cloning the repository and running tests with Swift.
Keywords: #phi4, AI, AI memory, Apple Silicon, BM25, ChromaDB, Core Data, Docker Compose, Elasticsearch, FAISS, GPU vector search, HNSW, Metal GPU, MiniLM CoreML, Pinecone, PostgreSQL, RAG, Redis, SQLite, Swift 62, Swift-native, USearch, WAL Ring Buffer, Wax, crash recovery, crash-safe, deterministic, deterministic RAG, documents, embeddings, hybrid search, hybrid search lanes, iOS 26, macOS 26, offline, on-device, reproducible retrievalKeywords: Wax, retrieval, tiered memory compression, token budgeting, token counting, vector database
github.com 5 days ago
|
930.
HN
IronClaw: a Rust-based clawd that runs tools in isolated WASM sandboxes
IronClaw is a Rust-based AI assistant designed with an emphasis on user data privacy and security, functioning through isolated WebAssembly (WASM) sandboxes that allow users to maintain control over their information by keeping it local, encrypted, and free from corporate influence. As an open-source project, it offers transparency and multiple layers of security defenses such as capability-based permissions and robust protection against prompt injection, data exfiltration, and credential exposure.
The tool supports various communication channels including REPL, webhooks, Telegram, and Slack, alongside a Docker sandbox for container execution, providing real-time updates via a web gateway interface. Its automation features include routines based on schedules or events, parallel job processing capabilities, and dynamic tool creation tailored to user needs. IronClaw also boasts persistent memory through full-text and vector search capabilities, flexible storage options, and consistent identity management across sessions.
Installation of IronClaw requires Rust 1.85+ and PostgreSQL 15+ with the pgvector extension, accessible via Windows Installer or PowerShell script on Windows, shell scripts on macOS/Linux, or compilation from source using Cargo. Users must set up a NEAR AI account for authentication during configuration, which includes database setup and secret encryption managed through system keychains.
The architecture of IronClaw incorporates components responsible for message handling, intent routing, job scheduling, execution environments (local or Docker), tool management, and web gateway integration, ensuring safety with prompt injection defenses and content sanitization processes. The development process encourages user interaction through an onboard command to start the interactive REPL and supports activities like code formatting, linting, and testing via Cargo.
Building on its predecessor, OpenClaw, IronClaw leverages Rust’s performance and memory safety features, a WASM sandbox environment for efficient security measures, PostgreSQL for robust data management, and prioritizes a comprehensive security-first design. It is available under the Apache License 2.0 or MIT License, offering flexibility in terms of usage rights.
Keywords: #phi4, AI assistant, Docker, HTTP webhooks, IronClaw, MCP Protocol, OpenClaw heritage Keywords: IronClaw, PostgreSQL, REPL, Rust, Slack, Telegram, WASM, agent loop, architecture, configuration, content sanitization, credential protection, database setup, dynamic tool building, endpoint allowlisting, features, identity files, installation, parallel jobs, pattern detection, persistent memory, philosophy, plugin architecture, policy enforcement, prompt injection defense, resource limits, routines engine, sandbox, sandbox security, scheduler, security, self-repair, telemetry, vector search, workspace filesystem
github.com 5 days ago
https://github.com/nearai/ironclaw?tab=readme-ov-file#a 5 days ago
https://www.near.org/ 5 days ago
https://cupcake.eqtylab.io/security-disclaimer/ 5 days ago
https://www.redpanda.com/ 4 days ago
https://news.ycombinator.com/item?id=47005607 4 days ago
https://seksbot.com/ 4 days ago
https://github.com/smartcomputer-ai/agent-os/ 4 days ago
https://docs.near.ai/cloud/verification/ 4 days ago
|
934.
HN
I ditched OpenClaw and built a more secure AI agent (Blink and Mac Mini)
The author describes creating a secure AI assistant on a Mac Mini using Blink and Tailscale to manage security vulnerabilities inherent in OpenClaw. While OpenClaw allowed building personal AI assistants with hardware control, it lacked robust security due to default network accessibility settings, leading to potential data exposure. To mitigate these risks, the author utilized Blink to provide isolated environments for each agent, preventing cross-agent access to sensitive information and enhancing overall security.
Tailscale was employed to make the Mac Mini invisible on the public internet by establishing an encrypted private network that requires identity-based authentication. This setup diminishes the need for extensive manual hardening compared to OpenClaw’s reliance on user-configured firewalls and proxies, thus simplifying maintenance efforts. The author further improved functionality by dividing their AI into two specialized agents—one dedicated to business tasks and another to personal activities like email and calendar management—thereby enhancing response quality through context separation and enabling more granular permissions.
To optimize costs, the system employs a multi-tiered model routing strategy that directs messages to appropriate AI models based on complexity. This approach allows efficient processing while running entirely on the Mac Mini, significantly reducing ongoing expenses compared to cloud-hosted solutions. The author underscores several key lessons: prioritizing security from inception, adopting efficient architectural patterns, maintaining stateless messaging adapters for scalability, and early specialization of agents for optimal performance.
Additionally, they highlight the importance of fast iteration during development, facilitated by tools like Mux that allow parallel coding sessions, thus enhancing productivity and innovation in the project. This comprehensive setup illustrates a practical approach to developing secure, efficient AI assistants on personal hardware while addressing common vulnerabilities found in other open-source solutions.
Keywords: #phi4, AI agent, API keys, Blink, Mac Mini, Mux, OpenClaw, PostgreSQL, Tailscale, architecture, container, credentials, development, digital assistant, encryption, hardening, integration, isolation, iteration, model tier, multi-channel messaging, personalization, security, specialization, webhook
coder.com 5 days ago
https://news.ycombinator.com/threads?id=ericpaulsen 5 days ago
https://news.ycombinator.com/item?id=46886875 5 days ago
https://news.ycombinator.com/item?id=46901199 5 days ago
https://news.ycombinator.com/item?id=46886533 5 days ago
https://news.ycombinator.com/threads?id=Zakodiac 5 days ago
https://seksbot.com/ 5 days ago
https://www.microcenter.com/product/688173/apple-m 5 days ago
https://www.hetzner.com/cloud/ 5 days ago
https://youtube.com/shorts/bof8TkZkr1I?si=FeMBYGn-d5Du- 5 days ago
https://github.com/Dicklesworthstone/destructive_comman 5 days ago
https://github.com/qwibitai/nanoclaw 5 days ago
|
936.
HN
FlexDesk – Open-source field service management for trades businesses
FlexDesk is an open-source field service management platform designed specifically for trades businesses such as HVAC technicians, plumbers, electricians, and landscapers. It provides robust features for job and client management, including scheduling, invoicing, and team coordination, all accessible from a unified dashboard. Key functionalities encompass real-time tracking of jobs and invoices, customizable weekly calendars, and a client CRM system that tracks status updates. Additionally, it supports professional invoicing linked to Stripe payments, enhancing financial operations.
To accommodate field workers who may not always have internet access, FlexDesk operates with an offline-first approach using IndexedDB for caching data locally, which is then synced when connectivity resumes. The platform uses a multi-tenant architecture secured by Prisma middleware, ensuring workspace isolation through row-level security. Its modular design breaks down domain logic into distinct modules, promoting better maintainability and scalability.
Technologically, FlexDesk leverages NestJS for the backend framework, Prisma ORM with PostgreSQL as its database, and React 18 alongside Next.js, Vite for front-end development, with mobile support provided through React Native. It offers flexible authentication options via Google OAuth or traditional email/password login methods. Notifications are supported by SMS (Twilio) and email services (SendGrid).
Setting up FlexDesk requires Node.js, pnpm, Docker for PostgreSQL, and proper configuration of environment variables such as DATABASE_URL, JWT_SECRET, and keys for external services. The project's structure is meticulously organized into various packages: backend, admin dashboard, customer-facing app, marketing website, mobile app, shared libraries, types, UI components, and AI agent utilities.
Development commands are comprehensive, covering dependency installation, server initiation, data migration, seeding, testing, linting, and package building. Deployment guidelines are provided in a separate document. FlexDesk is distributed under the MIT License, offering significant flexibility for customization and deployment across diverse environments.
Keywords: #phi4, CRM, Docker, FlexDesk, Google OAuth, HVAC, JWT, MIT License, NestJS, Nextjs, Nodejs, Nx, PostgreSQL, Prisma ORM, React 18, React Native, SMS notifications, SendGrid, Stripe payments, Twilio, Vite, dashboard, deployment, electricians, environment variables, field service management, invoicing, job management, landscapers, monorepo, multi-tenant, offline-first, open-source, plumbers, pnpm workspaces, scheduling, team management
github.com 5 days ago
|
940.
HN
Show HN: A Working Python VM Written Entirely in PL/PgSQL
Pgthon is an experimental initiative that aims to implement a Python virtual machine (VM) entirely in PL/pgSQL for PostgreSQL, emulating the CPython 3.11 bytecode VM without relying on extensions or foreign languages. This unique approach reconstructs Python's object model, type system, and bytecode interpreter using SQL constructs and stored procedures within a relational database schema. The architecture of Pgthon is distinctive as it utilizes SQL files to replicate CPython internals, representing each Python object as a database row. Its type system is realized through PostgreSQL stored procedures that mimic Python type slots, while the bytecode interpreter operates by executing instructions from tables in the core loop.
The project also includes a comprehensive setup requiring Docker and Python 3.11, initialized via `make all`. Pgthon offers an interactive Read-Eval-Print Loop (REPL) accessible with `make repl` for testing expressions directly within the VM environment. Various commands such as `make db`, `make schema`, and `make test` are provided to manage the database and execute tests.
Pgthon supports a range of Python features, including basic types, arithmetic operations, comparisons, control flow constructs like loops and conditionals, functions, classes, and built-ins. It successfully executes around 80 opcodes, encompassing list comprehensions, f-strings, and argument unpacking among others. Testing in Pgthon is facilitated by compiling Python code into CPython bytecode using `pgthon.py`, which then runs tests through a JSON RPC entry point (`py_run()`).
Overall, Pgthon serves as a proof of concept illustrating the feasibility of implementing a Python VM within a relational database framework, showcasing both innovative architectural approaches and functional capabilities.
Keywords: #phi4, CPython, Docker, Docker container, JSON RPC, PL/pgSQL, Pgthon, PostgreSQL, Python 311, Python VM, REPL, SQL, UUID, architecture, arithmetic, bootstrap, builtinsKeywords: Python VM, bytecode interpreter, classes, control flow, functions, interactive REPL, object model, opcode handlers, opcodes, relational database, schema, stored procedures, testing tool, type system, types
github.com 5 days ago
|
945.
HN
Unified API Proxy for OpenAI, Anthropic, and Compatible LLM Providers
Squirrel is an enterprise-level proxy designed to streamline the integration of applications with various Large Language Model (LLM) providers like OpenAI and Anthropic by serving as a unified API interface. Its core functionality includes seamless failover, load balancing, comprehensive observability, and management through a modern dashboard. Key features encompass support for different protocols with conversion capabilities, intelligent routing that enables rule-based decisions and cost optimization by selecting the most economical models, and ensuring high availability via automatic retries and configurable request timeouts.
The service is equipped to provide detailed insights into operations, including full request/response logging, token tracking, latency monitoring, and cost analysis, all while maintaining data privacy through sanitization features. The Squirrel dashboard, crafted with Next.js, TypeScript, and shadcn/ui, offers robust tools for provider management, model mapping, API key lifecycle oversight, and log accessibility.
Squirrel can be deployed easily using Docker Compose or as a standalone container, allowing users to configure providers, set base URLs, map models, and generate API keys. It facilitates application connections through the OpenAI SDK by adjusting the `base_url` to point to Squirrel’s endpoint. The service supports any compatible OpenAI or Anthropic API, alongside local LLMs such as Ollama and vLLM.
The development framework of Squirrel is compartmentalized into backend and frontend segments with components like API routes, protocol adapters, data access layers, and utilities. Tools like pytest for testing and Alembic for database migrations are utilized in its management. Released under the MIT license, Squirrel underscores a community-driven approach to development, reflecting its open-source ethos.
Keywords: #phi4, API Key Management, Anthropic, Cost Analytics, Cost Optimization, Data Sanitization, Docker Compose, Enterprise-Grade, High Availability, Intelligent Routing, LLM Gateway, Latency Metrics, Load Balancing, Log Viewer, Model Mapping, Nextjs, Nodejs, Observability, OpenAI, PostgreSQL, Protocol Conversion, Python, Rule-Based Routing, SQLite, Squirrel, Streaming Support, Token Tracking, TypeScript, Unified API Proxy, npm, uvicorn
github.com 5 days ago
|
960.
HN
Show HN: Open-Source AI Contact Center
ModelGuide is an open-source, self-hosted AI contact center solution aimed at eliminating vendor lock-in and reducing high SaaS fees by offering a comprehensive infrastructure for deploying contact centers. It includes tool integration, observability, configuration management, and analytics layers. The system features a Connector System that allows seamless connection of business systems via manifests and HTTP handlers, along with Tool Namespacing to support multiple instances on different agents without conflict. Its MCP Protocol standardizes tool discovery and execution across any compatible client.
The platform captures all interactions through Session Recording & Feedback for performance evaluation, supports multi-tenancy using PostgreSQL with row-level security, and offers authentication via magic link login and API keys, complemented by role-based access control (RBAC). ModelGuide's operation involves defining connectors in TypeScript, connecting agents through the MCP using API keys to retrieve tools, managing sessions to log interactions and feedback, and providing a dashboard for support teams to monitor metrics, transcripts, and performance.
Built on an advanced technical stack including Hono + Bun.js for the API layer, PostgreSQL 16 with Drizzle ORM for database management, and TanStack Start, React 19, Tailwind CSS v4 for the dashboard, it ensures robust functionality. Authentication is managed via JWT for users and API keys for agents. The future roadmap includes Zendesk integration, confirmation token flow, analytics aggregation, support for various chat channels, knowledge base connectors, agent comparison tools, live handoff capabilities, and a connector marketplace. Designed to be forkable and inspectable, ModelGuide allows organizations to tailor the solution without proprietary constraints and encourages community contributions without requiring a Contributor License Agreement (CLA).
Keywords: #phi4, AI Contact Center, Agent Configuration, Analytics Layer, Bunjs, Confirmation Gates, Connectors, Contributing, Dashboard, Docker, Hono API, MCP Protocol, Medusa Connector, Model Context Protocol, Multi-Tenant, Observability, Open-Source, PostgreSQL, RBAC, Roadmap, Self-hosted, Session Recording, Tech Stack, Tool Integration, TypeScript, Vendor Freedom
github.com 5 days ago
|
983.
HN
Show HN: Sqlmodel.org – open-source Browser Data Modelling
SQLModel.org is an open-source tool that offers a browser-based platform for visual data modeling without requiring installation or user accounts. It simplifies schema design through a canvas interface, allowing users to create conceptual and physical database models with ease. The application supports dual-layer modeling and incorporates AI technology to generate models from plain English descriptions. Additionally, it prioritizes privacy by operating locally unless cloud saving is explicitly chosen, ensuring data remains secure. Users can export their models as SQL DDL scripts, images, or JSON files, facilitating various use cases. Built with modern technologies like React 18, TypeScript, and Vite, the tool enhances user experience through intuitive interactions such as pan, zoom, and drag features.
SQLModel.org provides built-in functionalities for creating entities, relationships, physical tables, and foreign keys, enhancing its utility for database designers. Users can access the hosted version directly from sqlmodel.org or opt to run it locally by cloning the repository from GitHub. For those interested in AI enhancements, configuring with an OpenAI API key is optional. Contributions are welcomed under the MIT License, promoting both personal and commercial use, thereby encouraging community engagement and collaboration in its development and improvement.
Keywords: #phi4, AI-powered, MIT License, MySQL, PostgreSQL, React Flow, SQLModel, Vite, Zod, Zustand, browser-based, collaborative, data modeling, export SQL, foreign keys, offline, open-source, schema design, visual
github.com 5 days ago
|
989.
HN
Gotermsql
Gotermsql is a comprehensive terminal-based SQL Integrated Development Environment (IDE) crafted using Go, designed to prioritize simplicity and versatility. It distinguishes itself by requiring no configuration, needing only a single binary download for operation, thus supporting multiple databases independently of external dependencies like Python or Node.js. The IDE prominently supports PostgreSQL, MySQL, SQLite, and optionally DuckDB.
Key features of Gotermsql include real Vim keybindings, syntax highlighting, context-aware autocomplete, and efficient streaming results for handling large datasets. Users enjoy multi-tab editing capabilities and instant startup times thanks to Go's compiled nature. Additionally, the tool offers a schema browser with batch introspection features and allows customization through YAML configuration files.
Gotermsql also integrates a connection manager, maintains query history, and facilitates result exports in CSV or JSON formats. It can be installed via Homebrew, source build, or by downloading pre-built binaries from GitHub. The application's architecture comprises a CLI entry point, database adapters, UI components built with the reactive library Bubble Tea, and modules for autocomplete and configuration management. For development purposes, it employs Lip Gloss and Bubbles to manage styling and interactions, while adhering to best practices such as testing and code formatting.
As an open-source project under the MIT license, Gotermsql is designed to be accessible and modifiable by users worldwide, ensuring a broad community engagement in its continued evolution.
Keywords: #phi4, DuckDB, Go, MIT license, MySQL, PostgreSQL, SQL IDE, SQLite, architecture, autocomplete, binary, config, connection manager, development, export results, gotermsql, multi-database, multi-tab editing, query history, schema browser, startup, streaming results, vim keybindings
github.com 5 days ago
|
997.
HN
ScratchBird: MGA database engine with multi-dialect wire compatibility
ScratchBird is an advanced database management system designed around Firebird-style Multi-Generational Architecture (MGA) featuring true Multi-Version Concurrency Control (MVCC). It offers support for multiple SQL dialects, including native, Firebird, PostgreSQL, and MySQL wire protocols. Having completed its Alpha phase in February 2026, the project is now transitioning into Beta development. Key features of ScratchBird include comprehensive multi-dialect compatibility with versions such as PostgreSQL 3.0 and MySQL 4.1+, alongside robust security measures like built-in encryption, masking, role-based and column-level security (RLS/CLS), cryptographic audit chains, and SCRAM-SHA-256/512 authentication. The system also envisions distributed capabilities, with specifications for a Raft consensus-based cluster and mTLS security set to be implemented during the Beta phase.
The development journey of ScratchBird reached its Alpha milestone between July 2025 and February 2026, resulting in around 19,400 lines of code and over 3,600 successful tests at a 99.8% pass rate. Current efforts are focused on pre-Beta integration testing and performance benchmarking. Looking ahead to the Beta phase, plans include implementing distributed cluster features like sharding, replication, automated backup, and OpenTelemetry observability.
Extensive documentation supports the project, featuring over 1,926 files that cover specifications, architecture, testing procedures, and community guidelines, while encouraging contributions under strict standards. Post-Beta objectives involve production hardening, performance tuning, and exploring cloud-native deployment options, with potential future enhancements in SQL features. Licensed under IPL 1.0, ScratchBird aims to deliver robust database solutions prioritizing security, flexibility, and performance for users' evolving needs.
Keywords: #phi4, Alpha Complete, Alpha workstreams, BLOBs, Beta Project, Beta specifications, C++17/20, COPY flow control, CTest binaries, Docker container, Firebird, Firebird-style, GUI tools, LRU statement cache, MGA database engine, MVCC, MySQL, NoSQL extensions, OpenTelemetry observability, PKI infrastructure, PostgreSQL, RLS/CLS, Raft Consensus, SBWP v11, SCRAM, SCRAM-SHA-256/512 authentication, SQL harnesses, SRP auth, SSL, ScratchBird, ScratchBird-driver, ScratchRobin, TLS 13, UDR Connectors, UnixSocketIPCChannel, XDR Protocol, advanced security, audit logging, authentication methods, authorization, automated backup, backup orchestration, backup/recovery, cluster architecture, cluster manager, code base, compatibility scripts, cryptographic audit chainKeywords: ScratchBird, data masking, distributed cluster, distributed query, drivers CLI tools, encryption, foreign data wrappers, geospatial functions, implementation deferred, index manager, job scheduler, mTLS Security, multi-dialect wire compatibility, multi-transport IPC, password policy, protocol expansions, query optimizer, replication, schema introspection, security subsystem, sharding, stored procedures, test results, test suite, type mapping, vector search, wire protocol support
github.com 5 days ago
|
1028.
HN
A stack-buffer-overflow exercise with AddressSanitizer and PostgreSQL
AddressSanitizer, a tool aimed at identifying memory corruption issues, detected an 8-byte-read-stack-buffer-overflow within the PostgreSQL codebase due to a refactoring change that added optional parameters to system catalog functions. Despite passing local and Cirrus CI tests, AddressSanitizer flagged a failure because the function DirectFunctionCall2Coll was providing only two arguments instead of the required three. The error was identified through a backtrace pointing to an omitted argument in the call. To resolve this, it became necessary to use DirectFunctionCall3Coll to ensure all three expected arguments were correctly passed.
The article further outlines instructions for running AddressSanitizer locally with PostgreSQL, emphasizing configuration steps and environmental adjustments needed for effective error detection. This includes disabling compiler optimizations and setting specific rules tailored for capturing detailed stack traces and reporting errors accurately.
Keywords: #phi4, AddressSanitizer, DirectFunctionCall2Coll, DirectFunctionCall3Coll, PostgreSQL, compiler optimizations, configure, core dump, environment variables, memory corruption, pg_get_expr, regression tests, runtime instrumentation, stack-buffer-overflow
www.enterprisedb.com 5 days ago
|
1031.
HN
PostgreSQL v19: Password expiration warnings
The release notes for PostgreSQL version 19 detail the introduction of password expiration warnings as a key enhancement in its security features. This update focuses on increasing user awareness and improving account management by alerting users when their passwords are approaching expiration, thereby promoting prompt updates to ensure ongoing security integrity. The significance of this feature is underscored within HexaCluster's recent offerings or integrations that leverage PostgreSQL version 19, highlighting the broader impact and integration potential of this new functionality in enhancing database security practices.
Keywords: #phi4, HexaClusterLoading, Password expiration, PostgreSQL, authentication, database, feature, release, security, technical, update, v19, version, warnings
hexacluster.ai 5 days ago
|
1056.
HN
Show HN: Image prompt game with multi-signal CLIP/HSV/HOG scoring
This project introduces a competitive image prompt game aimed at enhancing users' prompt-engineering skills through iterative gameplay. Participants receive a target image and create text prompts to generate new images using an AI model, which are then evaluated for similarity based on several metrics: Semantic Alignment (CLIP) for conceptual congruence, Prompt Faithfulness (CLIP) for alignment with the original prompt, Color Similarity via HSV histogram overlap, and Structure Similarity through a HOG-lite method. These diverse metrics provide a balanced approach to scoring, addressing limitations found in single-metric systems by covering semantic content, color palette, and structural composition. The game's technical framework includes a Spring Boot backend, a CLIP scoring container, an external image generation service, Next.js frontend, and PostgreSQL database. Feedback is being solicited on metric weighting, potential benchmarking failure modes, and alternative methods to HOG-lite for evaluating structure. The game features two modes: Daily Challenge, offering consistent practice with the same prompts each day, and Speed Mode, which tests quick thinking against a timer. Both modes are available for free play, encouraging continuous engagement and improvement in prompt engineering skills.
Keywords: #phi4, CLIP scoring, HOG-lite, HSV histogram, Image prompt, Nextjs, PostgreSQL, Spring Boot, color similarity, daily challenge, leaderboard, prompt faithfulness, semantic alignment, structure similarity
promptmatch.app 6 days ago
|
1065.
HN
Redka: Redis Re-Implemented with SQL
Redka represents an innovative adaptation of Redis, reimagined through SQL to align with the traditional Redis API while utilizing SQLite or PostgreSQL as its storage backends. This approach enables data retention beyond the confines of RAM limitations and ensures reliable operations via ACID-compliant transactions. Key features include full compatibility with existing Redis commands and wire protocol (RESP), support for essential Redis data types such as strings, lists, sets, hashes, and sorted sets, along with SQL views that enhance data analysis and reporting capabilities. Redka can operate either in-process using a Go API or as an independent server.
The tool is versatile in its use cases: it serves as an embedded cache for Go applications utilizing SQLite, provides a lightweight testing environment for Redis-based applications, and accommodates PostgreSQL-first methodologies by offering Redis-like data structures. While Redka is deemed suitable for non-critical production environments and testing scenarios, it currently resides in maintenance mode with a focus on stability rather than introducing new features. The project encourages contributions, particularly for bug fixes and improvements.
Redka stands out as a unique solution that capitalizes on the foundational work of Redis, SQLite, and other projects to deliver an SQL-compatible variant of Redis, catering to developers who seek this type of functionality.
Keywords: #phi4, ACID transactions, Go API, PostgreSQL, RESP protocol, Redis, Redka, SQL, SQLite, benchmarks, data types, key-value store, maintenance mode, standalone server
github.com 6 days ago
|
1112.
HN
Show HN: VibeNVR – Modern, self-hosted NVR
VibeNVR is a self-hosted Network Video Recorder designed for modern use, bridging the gap between complex enterprise systems and basic hobbyist projects by offering an easy-to-deploy, privacy-focused solution with a contemporary architecture. It leverages Python's FastAPI for its backend, utilizing OpenCV and FFmpeg for video processing, while employing React and Vite on the frontend. PostgreSQL serves as its database, and Docker Compose is used for deployment, ensuring a seamless setup process. Key features include motion detection with smart recording capabilities, support for hardware acceleration from NVIDIA, Intel, and AMD, secure access through JWT-authenticated APIs, compatibility with reverse proxies like Nginx or Traefik, and a mobile-responsive user interface.
Security is prioritized by confining services to localhost and requiring JWT for media file access, allowing the system to operate securely behind a reverse proxy. At version 1.17.1 in beta, VibeNVR has garnered approximately 70 GitHub stars, indicating stability enough for production use, as evidenced by its deployment in home labs with multiple cameras on Proxmox.
As an open-source project under the MIT License, VibeNVR encourages community contributions and feedback while providing basic telemetry to guide development priorities, which users can opt out of for enhanced privacy. Installation is straightforward, requiring Docker & Docker Compose, with options to use a `docker-compose.prod.yml` file or clone the repository directly. Configuration necessitates setting up a `.env` file with secure keys.
Troubleshooting notes address permission issues on certain NAS systems and recommend security configurations like disabling seccomp/AppArmor or using privileged mode for deployment. Users can configure Nginx Proxy Manager to enable production access via SSL. Architecturally, VibeNVR comprises four main microservices: a React SPA for the frontend, a FastAPI server backend, a custom processing engine (VibeEngine) using OpenCV, and a PostgreSQL database. The project seeks community engagement through GitHub stars or donations to support its ongoing maintenance and development.
Keywords: #phi4, AppArmor, Docker, Docker Compose, FFmpeg, FastAPI, JWT, MIT License, NAS, NVR, OpenCV, PostgreSQL, Proxmox, Python, React, SSL, VibeNVR, Vite, Websockets, architecture, deployment, microservices, motion detection, privacy, reverse proxy, seccomp, security, self-hosted, telemetry
github.com 6 days ago
|
1119.
HN
Show HN: DuoORM – Symmetrical Active Record Pattern for SQLAlchemy 2.0
DuoORM is an ORM based on SQLAlchemy 2.0 tailored for developers who appreciate symmetrical synchronous and asynchronous APIs alongside explicit database control without sacrificing the capabilities of SQLAlchemy Core. It offers a unified API that seamlessly supports both sync and async operations, enabling chainable query methods such as `.where()`, `.order_by()`, and `.limit()` directly on models. CRUD operations are streamlined through methods like `Model.create()` and `instance.save()`. While emphasizing isolated database statements for clarity and control, DuoORM allows transaction management with the `db.transaction()` context manager and simplifies driver integration via URL configurations. It also integrates smoothly with Pydantic for data validation and provides an "escape hatch" to access raw SQLAlchemy queries when needed.
Installing DuoORM is straightforward using pip, supporting SQLite by default or other database drivers such as PostgreSQL and MySQL. The quickstart guide outlines the process of initializing a project structure using DuoORM's CLI, defining models, creating tables through migrations, and querying data. Comprehensive documentation is available on ReadTheDocs, and contributions to this open-source project under the MIT License are encouraged.
Keywords: #phi4, API, CLI, CRUD, Contribution, Database URLs, Documentation, DuoORM, License, MIT License, MIT License Keywords: DuoORM, Migration, Models, MySQL, ORM, PostgreSQL, Pydantic, Queries, SQLAlchemy, SQLite, Sync/Async, Transactions, Unit of Work
github.com 6 days ago
|
1124.
HN
Show HN: Quoracle, a recursive consensus-based multi-agent orchestrator (Elixir)
Quoracle is a Phoenix LiveView application designed to facilitate recursive multi-agent orchestration using consensus among multiple language models (LLMs). The platform enables users to create hierarchical agent systems where decisions are reached through agreement across various LLMs, thus enhancing decision-making reliability and diversity. It supports essential features such as spawning child agents, message communication, state persistence via PostgreSQL, and a real-time browser-based dashboard. While ideal for exploring multi-agent orchestration and experimenting with consensus-driven AI—particularly in complex tasks that benefit from diverse model perspectives—it is not suited for simple chatbot applications or single-model workflows, nor is it recommended for unsupervised production environments due to security concerns.
Setting up Quoracle requires API keys and a supported embedding model. For development, the necessary tools include Elixir (version 1.18 or higher), PostgreSQL (version 14 or higher), and libvips. Docker can be used for deployment, eliminating the need for Elixir or Erlang as it provides a self-contained release. The setup process involves cloning the repository, configuring environment variables, setting up databases, and initiating services.
For first-time users, initial steps include adding access credentials through an encrypted storage system, assigning models to specific roles such as embedding or answer engines, creating consensus profiles that define model participation and permitted actions, and establishing tasks by defining agent identities, work descriptions, success criteria, and other parameters. Usage tips suggest using diverse providers for varied reasoning styles and matching capability groups to task requirements to minimize errors.
Quoracle incorporates robust security features: it encrypts credentials at rest using AES-256-GCM via Cloak, scrubs secrets from action results, tags untrusted content with unique identifiers, and employs multi-model consensus as a defense against prompt injections. However, it lacks user authentication, sandboxing for shell execution, and network isolation, necessitating its operation in controlled environments like VMs or containers.
The application uses GenServer and DynamicSupervisor architecture for agent management, supports recursive hierarchies with child-agent spawning, budget allocation, real-time UI updates via LiveView, and PubSub topics. Contributions to Quoracle are encouraged, particularly discussions on significant changes, with testing involving code quality checks and asynchronous test runs. Licensed under the GNU Affero General Public License v3.0, Quoracle is currently in beta status and under active development.
Keywords: #phi4, API keys, Docker, Elixir, Phoenix LiveView, PostgreSQL, Quoracle, agent systems, capability groups, consensus-driven AI, encryption, language models, multi-agent orchestration, recursive hierarchy
github.com 6 days ago
|
1135.
HN
PostgreSQL 18.2, 17.8, 16.12, 15.16, and 14.21 Released
The PostgreSQL Global Development Group has issued updates for several versions—18.2, 17.8, 16.12, 15.16, and 14.21—to address five critical security vulnerabilities and resolve over 65 bugs. Among the security concerns are a memory disclosure issue in oidvector (CVE-2026-2003) with a CVSS score of 4.3, affecting versions prior to these updates; arbitrary code execution risks due to missing validation in intarray's selectivity estimator (CVE-2026-2004), heap buffer overflow in pgcrypto (CVE-2026-2005), and improper multibyte character length validation leading to buffer overruns (CVE-2026-2006), each with a CVSS score of 8.8; and a privilege escalation risk from a heap buffer overflow in pg_trgm (CVE-2026-2007) impacting only version 18. The updates also encompass various bug fixes, including enhancements to trigger behavior during MERGE operations, text substring search improvements for non-deterministic collations, and better NOTIFY error handling, alongside updated time zone data files to the tzdata release 2025c. Users can apply these updates without a complete database dump or reload, although those using ltree columns might need reindexing. Additionally, users who have skipped previous versions are advised to review earlier release notes for additional update steps.
Keywords: #phi4, CVE-2026-2003, CVE-2026-2004, CVE-2026-2005, CVE-2026-2006, CVE-2026-2007, PostgreSQL, bug fixes, bugs, heap buffer overflow, intarray, ltree, pgcrypto, reindex, release, security vulnerabilities, time zone data, update releases
www.postgresql.org 6 days ago
|
1139.
HN
Show HN: Open-Source Inbox-as-a-Service for LLM Agents
NornWeave is a self-hosted, open-source Inbox-as-a-Service API designed to enhance the functionality of emails for Large Language Model (LLM) agents by addressing limitations in traditional stateless email APIs. It offers a robust solution with features such as virtual inboxes that provide dedicated email addresses per AI agent, supporting databases like SQLite or PostgreSQL. NornWeave enhances user interaction through its smart threading capabilities, automatically organizing emails based on headers and converting HTML content into Markdown format. This API also provides thread summaries utilizing services like OpenAI, Anthropic, or Gemini keys, facilitating comprehensive historical context for ongoing conversations. Integration is streamlined via a full REST API, allowing seamless email management and compatibility with MCP clients such as Claude and Cursor, enabling attachment text extraction.
NornWeave offers advanced webhook ingestion from providers including Mailgun, AWS SES, SendGrid, and Resend, enhancing its versatility in email handling. Security features are incorporated through domain filtering and send rate limiting to effectively manage incoming email traffic. The modular architecture of NornWeave allows for straightforward swapping of different email providers, offering flexibility and customization based on user needs.
The setup process is designed to be efficient, with options for rapid deployment using Docker or from source installation, making it particularly suitable for AI applications requiring context-aware email interactions. Inspired by Norse mythology, NornWeave metaphorically mirrors the role of the Norns in weaving fate at Yggdrasil, symbolizing its function in structuring and organizing email data intricately and effectively.
Keywords: #phi4, AWS SES, Anthropic, Docker, Domain Filtering, Email API, Gemini, Inbox-as-a-Service, LLM Agents, MCP Integration, Mailgun, Modular Architecture, NornWeave, Norns, OpenAI, PostgreSQL, REST API, Resend, SQLite, Send Rate Limiting, SendGrid, Smart Threading, Virtual Inboxes, Webhook Ingestion, Yggdrasil
nornweave.datacovey.com 6 days ago
|
1151.
HN
From 3 Minutes to 7.8 Seconds: Improving on RocksDB performance
The document emphasizes a substantial enhancement in RocksDB's performance, achieving a reduction in processing time from 3 minutes to just 7.8 seconds. This improvement signifies a marked increase in efficiency for operations involving this database technology. Additionally, the introduction of SereneUI is detailed—a new database client tailored specifically for SereneDB. Beyond its primary design, SereneUI offers compatibility with PostgreSQL as well, thereby broadening its applicability and utility. The purpose of SereneUI is to facilitate more streamlined workflows in managing analytics data, suggesting an integrated approach to handling complex databases within diverse environments. This combination of performance improvement in RocksDB and the introduction of a versatile client like SereneUI underscores advancements aimed at optimizing database management processes and enhancing user experiences in analytics-driven fields.
Keywords: #phi4, 3 Minutes, 78 Seconds, From, Improving, PostgreSQL, RocksDB, SereneDB, SereneUI, analytics, data workflow, database client, interface, performance
blog.serenedb.com 6 days ago
|
1161.
HN
From 3 Minutes to 7.8 Seconds: Improving on RocksDB performance
The article explores two significant developments: an enhancement in RocksDB's performance, achieving a reduction in processing time from three minutes to 7.8 seconds, which underscores substantial efficiency improvements. Additionally, the launch of SereneUI is announced as a novel database client specifically tailored for integration with SereneDB while maintaining compatibility with PostgreSQL. This dual announcement highlights advancements both in database processing speed and user interface innovation, catering to enhanced functionality and interoperability within data management systems.
Keywords: #phi4, 3 Minutes, 78 Seconds, From, Improving, PostgreSQL, RocksDB, SereneDB, SereneUI, analytics, data workflow, database client, interface, performance
blog.serenedb.com 6 days ago
https://blog.serenedb.com/building-faster-ingestion 6 days ago
|
1178.
HN
Show HN: Vibe Deploy... Deploy full-stack apps to your own servers via AI
Vibe Deploy is an innovative platform designed to streamline the deployment of full-stack applications by utilizing AI tools like Claude Code. It enables developers to rapidly progress from coding to running live apps on their servers through RunOS management. The service automates essential tasks such as setting up databases (e.g., PostgreSQL, MySQL), caching services (like Redis-compatible Valkey), and object storage (e.g., MinIO) without the need for manual configurations or traditional tools like Git or Docker.
To begin using Vibe Deploy, users establish a RunOS account and configure their project via the `runos mcp configure claude` command, which sets up an MCP server to connect AI tools with RunOS services. This setup allows for direct provisioning of necessary resources and supports rapid deployment capabilities. Applications such as polling apps, handyman service websites, or blogs can be built and deployed within minutes.
Beyond deployment, Vibe Deploy acts as a comprehensive development environment through its MCP connection, enabling developers to perform ongoing tasks like database querying, cache management, and object storage interaction directly from AI sessions. This capability facilitates faster debugging by providing unified access to application logs, services, and code.
Security and flexibility are maintained as users control what the AI can access via categorized servers (read/write and sensitive/non-sensitive). Additionally, RunOS supports scaling from single-server deployments to full redundancy setups without needing platform migration, addressing common deployment challenges by reducing setup time and complexity. This allows developers to focus on innovation and swiftly bring ideas to life.
The platform is versatile for various project needs, from prototypes to production applications, offering seamless growth with isolated clusters for development, staging, and production environments. Vibe Deploy empowers developers by eliminating traditional barriers in the deployment process, fostering a streamlined development experience that transitions smoothly from idea generation to live application deployment.
Keywords: #phi4, AI, Claude Code, DNS, MCP server, MinIO, PostgreSQL, Redis, RunOS, SSL certificates, SaaS apps, Vibe Deploy, clusters, databases, deployment, domains, environment variables, environment variables Keywords: Vibe Deploy, infrastructure, live app, production, provisioning, servers, services
runos.com 6 days ago
|
1232.
HN
Show HN: Production-Ready NestJS Back End (Multi-Tenancy, Event-Driven)
The portfolio highlights a Brazilian Computer Engineering student's proficiency in advanced backend development using NestJS, focusing on scalable, cloud-native systems. The work includes three key projects: a SaaS Backend Platform, an Event-Driven Integration Service, and a Cloud Deployment Showcase.
The **SaaS Backend Platform** project employs technologies such as TypeScript, Node.js, NestJS, PostgreSQL, Prisma, JWT, Redis, and Docker to create a multi-tenant system with row-level data isolation. It features comprehensive user management, CRUD operations, payment processing through a simulated Stripe API, and asynchronous email job handling. Development is supported by tools like Docker Compose for containerization, Jest for testing, and ESLint and Prettier for code quality assurance.
The **Event-Driven Integration Service** uses a similar tech stack with the addition of BullMQ for queue management. It emphasizes asynchronous webhook processing with retry capabilities, structured logging via Winston, and distributed tracing through OpenTelemetry and Jaeger. Development tools include Docker Compose and adherence to NestJS best practices, ensuring robust system architecture.
In the **Cloud Deployment Showcase**, AWS (with professional experience), Railway, Docker, Nginx, and GitHub Actions are utilized for a production-ready deployment leveraging infrastructure as code on Railway. This includes CI/CD pipelines via GitHub Actions and observability tools for monitoring. The student's professional context involves managing similar deployments using AWS services like ECS (Fargate), RDS, and ElastiCache.
Overall, these projects underscore the student’s expertise in scalable SaaS development, multi-tenancy, event-driven architectures, cloud deployment, and CI/CD automation, reflecting a strong grasp of RESTful API design, authentication, containerization, and testing strategies essential for maintaining production environments. The portfolio invites contact to explore the architecture and implementation details further.
Keywords: #phi4, AWS, Asynchronous, Authentication, Backend, BullMQ, CI/CD, CRUD, Cloud Deployment, Containerization, Docker, Event-Driven, GitHub Actions, Infrastructure, JWT, Multi-Tenancy, NestJS, Nodejs, Observability, OpenTelemetry, PostgreSQL, Prisma, RESTful API, Railway, Redis, SaaS, Scalable, TypeScript, Webhook Processing
github.com 6 days ago
|
1248.
HN
Self-hosted, memory-augmented AI chat that works with any LLM
Cathedral is a self-hosted AI chat application designed to enhance conversational interactions by integrating Large Language Models (LLMs) with persistent memory stores, facilitating seamless conversations through semantic search capabilities. It supports multiple LLM backends, including OpenRouter and local models, and provides optional features such as file access, shell commands, web browsing, and multi-modal support. The core functionalities include threaded conversations with context retrieval via the Knowledge System (MemoryGate), which maintains a knowledge graph of facts, concepts, patterns, and relationships derived from chat histories for future reference. Additionally, the Document Library (ScriptureGate) manages document storage and content integration using semantic search. Cathedral allows tool interactions through ToolGate, employing a JSON-in-text protocol adaptable to various LLMs with configurable policies. It ensures secure system operations via features like shell command execution, file management, and web browsing capabilities, backed by robust security measures including AES-256-GCM encryption and Argon2id password hashing, alongside session locking and path validation.
Built using FastAPI and PostgreSQL with pgvector for storage, Cathedral is optimized for local deployment and offers a comprehensive REST API. It supports configuration through environment variables or JSON files, promoting ease of use. Deployment should be handled carefully to maintain security, recommending VPN-only access by default, supported by an example nginx configuration for HTTPS connections with basic authentication. The project encourages open-source contributions via GitHub, emphasizing adherence to development guidelines and the importance of writing tests for new features. Overall, Cathedral provides a versatile platform that augments AI chat interfaces with context-aware memory capabilities, supporting various LLMs while ensuring secure and customizable deployments.
Keywords: #phi4, AI chat, Cathedral, Docker, Docker Comma-separated list: Cathedral, Docker Final Comma-separated List: Cathedral, Docker Final Keywords (12 or fewer): Cathedral, Docker Final Keywords: Cathedral, Docker Simplified Keywords: Cathedral, FastAPI, LLM, OpenRouter, PostgreSQL, REST API, REST API Comma-separated List: Cathedral, SQLite, ToolGate, conversation threads, deployment, document library, embeddings, file access, knowledge system, local models, memory-augmented, multi-modal, network restrictions Keywords: Cathedral, personality management, pgvector, reverse proxy, reverse proxy Selected Keywords: Cathedral, security, self-hosted, semantic search, shell commands, vector similarity, web browsing
github.com 7 days ago
https://github.com/PStryder/Cathedral 6 days ago
|
1249.
HN
Show HN: MemoryGate – Open-source persistent memory for AI agents via MCP
MemoryGate is an open-source solution developed to address context loss in AI agents caused by platform updates or changes by providing persistent memory. It acts as a semantic memory layer independent of any single model or platform, employing the Model Context Protocol (MCP) for seamless storage and retrieval across various AI agents like Claude Desktop, ChatGPT, and Cursor. Its core features include utilizing vector embeddings to recall information based on meaning rather than keywords and adjusting memory strength through confidence-weighted observations depending on the available evidence. MemoryGate also offers automatic lifecycle management, ensuring valuable data remains accessible while less significant information is archived, and employs an append-only architecture to maintain a lineage trail of memories. The system facilitates the creation of knowledge graphs linking observations, patterns, and documents, supports organizational isolation with multi-tenant capabilities, and incorporates robust security measures such as OAuth 2.0, audit logs, and rate limiting for production-grade infrastructure. Notably, MemoryGate is not designed to function as a RAG pipeline or prompt injection tool, instead providing flexibility in switching between AI models while maintaining consistent memory. Developed by an experienced enterprise solutions engineer, the project utilizes technologies like Python/FastAPI, PostgreSQL with pgvector, Redis, and is deployable on Railway. The open-source initiative, governed by Apache 2.0 licensing, allows for self-hosting or offers a hosted SaaS option for users who prefer not to manage their infrastructure independently. Additional resources are accessible via GitHub, the official site, and linked documentation.
Keywords: #phi4, AI agents, FastAPI, MCP, MemoryGate, OAuth 20, PostgreSQL, RAG pipeline, Railway, Redis, SaaS, append-only architecture, cold memory search, confidence-weighted observations, enterprise solutions engineering, evidence chains, knowledge graphs, lifecycle management, multi-tenant, open source, persistent memory, prompt injection, self-hostable, semantic memory, vector embeddings
www.memorygate.ai 7 days ago
|
1317.
HN
Databases should contain their own Metadata – Use SQL Everywhere
Floe is developing an innovative database system designed to enhance metadata accessibility by allowing extensive querying about the database itself using SQL. This system simplifies diagnostics and data management for performance issues by providing insights into various aspects such as user activities, storage usage, and resource consumption through system views like `sys.table`, `sys.view`, and `sys.function`. Floe aims to make complex diagnostics straightforward via familiar SQL syntax without necessitating specialized tools or interfaces.
A key design principle of the system is treating all interactable concepts as queryable objects, empowering developers and data engineers with robust diagnostic capabilities directly through SQL queries. Additionally, Floe supports both contemporary and traditional metadata standards, including ADBC and PostgreSQL protocol, ensuring wide compatibility across different clients. Implementation-wise, it employs Snowflake IDs for efficient key management in distributed environments while addressing challenges associated with legacy metadata standards to maintain tool compatibility.
Floe's evolving system schema is designed to provide a comprehensive architectural view via its views, aligning with its goal of being an accessible and user-friendly database suitable for both advanced users and newcomers.
Keywords: #phi4, ADBC, Compatibility, Databases, Diagnostics, Floe, Metadata, Performance, PostgreSQL, Protocols, Queries, SQL, Sessions, System Views
floedb.ai 7 days ago
|
1322.
HN
"Have I Been Stalked" post-mortem
The "Have I Been Stalked" project aimed to develop a service allowing users to check if their devices were listed in stalkerware databases, using Django and SQLite for its prototype due to simplicity considerations. It incorporated privacy-focused features like hashed IMEIs and random fake IMEI generation during queries to safeguard user identities. Despite being technically viable, the initiative faced significant legal and ethical challenges related to handling sensitive data connected to stalkerware, providing appropriate support without stepping into direct victim assistance beyond their capacity, and ensuring robust security for such a critical service. Concerns about potential risks to users upon discovering device compromise led to shelving the project. The team deemed it too risky for Echap, a non-profit organization, to pursue due to these challenges and shifted focus to other initiatives that better aligned with their capabilities and mission, despite its technical intrigue and privacy-conscious design.
Keywords: #phi4, Django, Flask, IMEI, PostgreSQL, Stalkerware, data minimization, database leaks, encryption, hcaptcha, legal challenges, non-profit, privacy, security, sensitive data, sqlite, web development
dustri.org 7 days ago
|
1326.
HN
Building a production-grade SaaS product just with AI
The OnboardingHub project stands as an exemplary case of rapid SaaS product development achieved through AI-assisted methodologies. Developed over approximately two months from December 2025 to February 2026 by a solo developer, the project involved transforming an existing Node/React application into a new Rails-based version using Claude Opus 4.5 and later 4.6 for AI-powered code generation, testing, and documentation. The developer focused on architectural oversight, product management, and reviews while leveraging AI to handle most of the coding.
Key elements in this accelerated development process included adopting Rails 8.1.1 with Hotwire and Tailwind CSS, implementing multi-tenancy using `acts_as_tenant`, transitioning to PostgreSQL for better UUID support, and moving from Kamal to Heroku to streamline deployment management. Notable terminological shifts were made for clarity, such as renaming Hub to Guide.
Despite a production incident caused by misconfigured database migrations leading to cascading failures in early February, the team chose not to revert changes but rather resolved issues through forward-moving commits. This approach emphasized learning and resilience, with subsequent efforts focusing on bug fixes, marketing pages, and adding a full account deletion feature supported by comprehensive testing.
The project highlighted AI's potential as a significant force multiplier in software development, enabling what typically requires a larger team to be accomplished swiftly by an individual developer. High commit velocity peaked at 67 commits in one day, illustrating intense activity leading to stabilization as the project neared completion. However, certain areas like documenting architectural decisions and user demographics were found lacking, pointing out avenues for further improvement in transparency and documentation practices.
In summary, OnboardingHub exemplifies a high-velocity software development lifecycle enabled by AI assistance, showcasing resilience amidst challenges while emphasizing the need for better decision-making and insight documentation in future projects.
Keywords: #phi4, 2FA, AI co-authorship, ActiveStorage, Claude-driven project, Cloudflare R2, Content Security Policy, Dependabot PRs, Heroku, Honeybadger, Hotwire, Kamal, Markdown, PostgreSQL, Puma workers, Pundit policies, R14 errors, Rails, Replit, SEO, SQLite, SaaS, ShadCN components, SimpleCov, Sitepress, Solid Queue, Stripe, Tailwind CSS, UI reference implementation, UUIDv7, account deletion, analytics, architecture document, authentication system, authorization, billing, checksum error, commit history, component library, database pool, db:migrate, documentation, domain model, email enumeration, feature branches, git history, infrastructure, marketing pages, media management, multi-tenant, onboarding, password strength, production fire, resilience, reverts, rollback, startup sprint, subscription management, tests, transaction wrapping, welcome guide
world.hey.com 7 days ago
|
1338.
HN
An Ode to Merge Join
"An Ode to Merge Join" emphasizes the efficiency and elegance of the merge join algorithm in synchronizing data sources with relational databases, particularly due to its low memory footprint compared to other methods like hash joins. While hash joins require significant memory (up to 3 GB), merge joins operate within a constant space of 19 MB by utilizing sorted inputs and advancing pointers based on key comparisons. This approach is especially advantageous for synchronization tasks—such as comparing CSV files with database records—without needing to load entire datasets into memory.
The algorithm functions by processing two sorted iterables, outputting pairs when keys match or indicating inserts/deletes through the presence or absence of elements. Its efficiency is highlighted in environments where data possesses a natural order (e.g., sequential IDs), allowing sorting at the source or destination rather than during the join process itself. This characteristic makes merge joins particularly suitable for scenarios with limited resources.
In practice, Python implementations can achieve constant memory usage through concise scripts using generators to stream data row-by-row, maintaining performance on par with hash joins while conserving memory. Benchmarks comparing merge join with other methods—such as SQL join and index lookup—using SQLite show that although hash joins are comparable in speed, they consume significantly more memory.
Merge joins have found practical applications in tools like Git for diff computations and GNU Coreutils for merging text files. Despite their simplicity, the algorithm has deep historical roots, tracing back to early concepts by John von Neumann and further development in IBM's System R database system. Overall, merge joins are presented as a powerful tool for managing large datasets efficiently with minimal memory overhead, making them ideal for various data synchronization tasks.
Keywords: #phi4, CSV-to-database, GNU Coreutils, Git, Merge join, PostgreSQL, Python, RAM usage, SQL JOINs, SQLite, algorithm, data sync, diff computation, generators, hash table, lockstep iteration, memory efficiency, psycopg2, relational database, server-side cursors, sorted iterables
ender672.github.io 7 days ago
|
1362.
HN
Show HN: SQLModel – open-source data modeling in the browser
SQLModel is an innovative open-source tool designed to facilitate data modeling directly within a web browser, eliminating the need for heavy software installations or vendor lock-in. It targets data engineers, analysts, and developers by providing a platform where they can design, iterate on, and share database schemas visually and interactively. With its dual-layer modeling feature, users can create both conceptual schemas—comprising entities and relationships—and refine these into detailed physical tables.
The tool stands out with its AI-powered capabilities, allowing users to describe systems in plain language for the generation of complete data models, which support various patterns like OLTP and Analytics/Star Schema. Additionally, SQLModel prioritizes user privacy by operating entirely locally without requiring server connections or account setups, ensuring all data remains on the user’s device.
SQLModel offers a modern user experience built using React Flow, enabling smooth drag-and-drop interactions and customization options such as dark and light modes with keyboard shortcuts. It is easily accessible via sqlmodel.org for direct use in the browser, or can be set up locally by cloning its repository and installing dependencies. Optional AI integration through OpenAI's GPT-4o-Mini further enhances its functionality but requires an API key.
Users interact with SQLModel by creating entities and relationships within a Conceptual View interface, defining detailed relationship cardinalities, and generating physical tables either manually or via AI suggestions. These tables can be refined to include specific columns, keys, data types, and foreign keys through the Physical View interface. The tool supports exporting models as JSON files, SQL scripts, or images for easy sharing and documentation.
The technology stack underpinning SQLModel includes React 18 with TypeScript for UI components, React Flow for canvas rendering, Zustand for state management, Vite for development/build optimization, and Zod for schema validation, ensuring a robust and efficient user experience. The project welcomes community contributions through issue reporting and pull requests and is licensed under the MIT License, allowing free use in both personal and commercial contexts.
Keywords: #phi4, AI assistance, Analytics, MIT License, MySQL, OLTP, PostgreSQL, React Flow, SQLModel, TypeScript, Vite, Zod, Zustand, browser-based, conceptual view, contributing, data modeling, database schemas, export SQL DDL, open-source, physical tables, privacy-first, star schema, tech stack
github.com 7 days ago
|
1369.
HN
Pax: The Cache Performance You're Looking For
The article discusses the inefficiencies of PostgreSQL's traditional N-ary Storage Model (NSM) in handling data caching, where loading entire 8KB pages results in unnecessary bandwidth consumption and cache pollution due to unneeded column access during queries. Researchers Boris Novikov and Anastasia Ailamaki identified these issues and introduced Pax as a solution. Pax restructures data into "minipages" within the existing page size, enabling selective column retrieval for specific queries, thus enhancing cache efficiency and reducing cache misses by up to 75%. While retaining PostgreSQL's essential ACID properties crucial for Online Transaction Processing (OLTP), Pax avoids the limitations of full-scale columnar storage systems like Parquet, which are better suited for analytical workloads but lack transactional mutability. Pax is particularly advantageous for wide tables with selective queries and mixed workloads, though it faces challenges in narrow tables or high random access scenarios due to reconstruction overheads. Despite being theoretical, Pax has demonstrated substantial performance improvements on older hardware, with expectations of even greater gains on modern systems. The implementation hurdles include managing dead tuples, Write-Ahead Logging (WAL) complexities, and vacuum processes, yet the concept presents a promising avenue for optimizing PostgreSQL's data handling capabilities.
Keywords: #phi4, Anastasia Ailamaki, CPU/cache bottleneck, MVCC, N-ary Storage Model (NSM), NVMe, OLAP, OLTP, PAX, Parquet, PostgreSQL, TPC-H queries, WAL, buffer manager, cache performance, cache pollution, columnar storage, data cache misses, database storage layouts, minipages, range selections, sequential scans, transactional DBMSs, vacuum
mydbanotebook.org 7 days ago
|
1376.
HN
Show HN: Sigilla – Spaced repetition for browser tabs (stop hoarding)
Sigilla is a beta-stage browser extension crafted by northerndev to enhance productivity through spaced repetition techniques for managing articles and research materials. It offers an innovative alternative to traditional bookmarking by enabling users to save, highlight, and retrieve content based on semantic meaning using AI-driven search capabilities. The tool prioritizes user privacy, utilizing Vite and Tailwind for its frontend, Supabase with PostgreSQL for backend services, and incorporating context-aware searches through vector embeddings without employing tracking pixels. Additionally, Sigilla allows users to export their data in Markdown or JSON formats. As a free resource, it seeks to provide a privacy-first solution for efficient research management, with further details available on the project's website at https://www.sigilla.net/reply.
Keywords: #phi4, AI search, JSON, Markdown, PostgreSQL, React, Sigilla, Supabase, Tailwind, Vite, articles, beta, browser tabs, context-aware search, highlights, obsidian-friendly, obsidian-friendly Keywords: Sigilla, privacy-first, reading companion, research tool, spaced repetition, vector embeddings
news.ycombinator.com 7 days ago
https://www.sigilla.net/ 7 days ago
|
1378.
HN
A curated list of excellent books to learn PostgreSQL
This curated selection of books serves as a comprehensive guide for learning PostgreSQL, offering resources suitable for beginners and experts alike. The collection includes general and modern guides like "PostgreSQL 16 Administration Cookbook" by Gianni Ciolli et al., providing task-oriented recipes for managing PostgreSQL 16 in production environments, and "High Performance PostgreSQL for Rails" by Andrew Atkinson, which focuses on performance tuning specifically for Ruby on Rails applications using PostgreSQL. Additionally, it covers advanced and niche topics, though specific titles are not mentioned, indicating an emphasis on specialized areas of expertise. Community favorites such as "PostgreSQL: Up and Running" by Regina Obe & Leo Hsu offer practical insights into usage and administration, while "Practical PostgreSQL" by Joshua Drake & John Worsley is recognized for its hands-on approach. For those interested in application development and performance, "The Art of PostgreSQL" by Dimitri Fontaine explores SQL-centric design best practices and performance optimization strategies. The list underscores the importance of aligning book editions with the user's specific version of PostgreSQL due to rapid advancements in database technology. While official documentation remains a crucial resource for detailed reference, these books provide contextual knowledge and real-world experiences. The collection is dynamic, encouraging community contributions to keep it current by organizing entries by version or adding new recommendations.
Keywords: #phi4, Administration, Advanced Internals, Application Development, Beginner-Friendly, Books, Community Recommendations, Contributing, Documentation, Editions, Happy Querying, Performance Tuning, PostgreSQL, Pull Request, Ruby on Rails, SQL-Centric Design, Task-Oriented Recipes
github.com 7 days ago
|
1385.
HN
SQL /* comments */ can be nested
SQL supports two primary types of comments: single-line comments initiated with `--` and multiline comments enclosed within `/* */`. Notably, SQL allows for nested multiline comments, a feature uncommon in many programming languages, enabling the commenting out of code that already contains `/*...*/` comments. While standard SQL regards comments as token separators similar to whitespace, some database systems permit special instructions called hints within comments, despite these not being part of the official SQL specification.
Different database systems offer additional comment styles borrowed from other programming languages. Systems such as BigQuery, Db2 (LUW) 12.1.3, DuckDB 1.4.0, H2 2.4.240, MariaDB 12.1.2, MySQL 9.6.0, Oracle DB 23.26.1, PostgreSQL 18, SQL Server 2025, and SQLite 3.51.0 have implemented these features, each managing them in unique ways. This variability underscores the necessity for developers to understand the specific comment implementations of each database system they work with. Related standards provide further insights into bracketed comments and end-of-line indicators, enhancing comprehension of SQL commenting practices across various platforms.
Keywords: #phi4, BigQuery, Bracketed comments, Db2, DuckDB, H2, MariaDB, MySQL, Oracle DB, PostgreSQL, SQL, SQL Server, SQLite, asterisk-slash, comments, dashes, hints, programming languages, slash-asterisk, source code, standard SQL, vendors, whitespace
modern-sql.com 7 days ago
|
1392.
HN
CoLoop (YC S21) Is Hiring Ex Technical Founders in London
CoLoop, established in 2020 by university students and participating in Y Combinator's S21 cohort, is expanding its team of ex-technical founders based in London to advance its mission of transforming businesses into customer-centric entities akin to Amazon. The company strives to become a global leader as the "customer context layer," empowering employees with rapid and intuitive access to essential customer insights. This ambitious goal involves leveraging technologies such as Prompt Engineering, Node.js, Python, React, TypeScript, and PostgreSQL.
At CoLoop, engineers operate within a flat organizational structure, giving them ownership over complete product development cycles without traditional product managers, thereby fostering an environment of autonomy reminiscent of startup founders' experiences. The company is actively seeking ex-founders with expertise in AI startups, complex agent systems, and AI-augmented engineering. These candidates are expected to navigate the tension between rapid iteration and robust core development effectively while possessing strong communication skills to convey intricate AI concepts to diverse audiences.
The application process for potential hires consists of a screening interview, technical assessment, work sample presentation, and an optional paid contract day to evaluate practical fit within the company's dynamic culture. CoLoop prizes diversity in experiences and invites applications from individuals who may not fully meet all job criteria but demonstrate alignment with their overarching objectives and values.
Keywords: #phi4, Agentic AI, Claude Code, CoLoop, CoWorking, Codex, Conductor, Context Engineering, Customer Obsessed, Enterprise Customers, Ex-Founders, Flat Structure, Greptile, Growth Experiment, London, Multi-Agent Systems, Nodejs, PostHog, PostgreSQL, Product Ownership, Prompt Engineering, Python, React, Technical Founders, TypeScript, YC S21
www.workatastartup.com 7 days ago
|
1436.
HN
Do you really need Supabase for you vibe coding project
For vibe coding projects, it's recommended to start with simple solutions like JSON or SQLite for their efficiency and cost-effectiveness in managing initial data needs without unnecessary complexity. JSON is suitable for static directories of information requiring minimal updates, whereas SQLite offers dynamic data support embedded within the server, minimizing overhead. For those needing a NoSQL database or a simpler setup, Firebase provides flexibility and ease of use with no schemas, ideal unless complex SQL queries are anticipated in future scaling. Content Management System SaaS options should be considered for blog-like projects where content management is crucial. Although Supabase is a popular PostgreSQL-based Database-as-a-Service that simplifies database management, it may be excessive for side projects and could lead to wasted resources early on. RAG frameworks are only recommended when there's a need for advanced AI search capabilities alongside growing data sizes. The guide advises against self-hosting databases due to their complexity and inefficiency unless the necessary expertise is available, emphasizing starting simple, quickly deploying the product, and scaling infrastructure based on actual user demand.
Keywords: #phi4, AI chat, CMS SaaS, CO₂ overhead, Chroma, DB schema changes, Firebase, JOINs, JSON, LLM, LlamaIndex Cloud, NoSQL, ORM, PostgreSQL, RAG, Retrieval-Augmented Generation, SQLite, Supabase, WordPress/Elementor, complexity, cost, data directory, data migration, database options, feature requests, hosting, hype, infrastructure, performance, private documents, records management, scalability, schema, side projects, simplicity, traffic, vector database, vector search, vibe coding
app.webjourney.pro 8 days ago
|
1443.
HN
Debugging random slow writes with GIN indexes in PostgreSQL
The article addresses challenges encountered with inconsistent performance during slow database writes involving GIN indexes within a PostgreSQL setup hosted on an AWS Aurora RDS instance. The issue manifested as sporadic delays in UPDATE/INSERT operations on a large table containing millions of rows and several indexes. Initial investigations ruled out common causes such as high write volume, batched writes, or excessive indexing based on controlled tests.
Subsequent analysis leveraged PostgreSQL tools including `log_lock_waits`, `auto_explain`, and execution plans from the EXPLAIN command to pinpoint performance inconsistencies. The root cause was identified as the GIN index's "fastupdate" feature, which periodically triggered intensive cleanups of pending list entries, leading to variable write times. Disabling fastupdate resolved these spikes but resulted in generally slower write operations.
Several strategies were considered to balance performance, including aggressive vacuuming, modifying the `gin_pending_list_limit`, and running background cleanup tasks. Ultimately, reducing the `gin_pending_list_limit` for the specific index proved effective in stabilizing write times without disabling fastupdate entirely. This adjustment led to consistent and predictable database performance over a week.
The experience prompted further discussion about the impact of GIN indexes on write performance and considerations related to full-text search capabilities within PostgreSQL, highlighting areas for future exploration and optimization.
Keywords: #phi4, AWS Aurora RDS, Debugging, EXPLAIN ANALYZE, GIN indexes, ORMs, PostgreSQL, REINDEX, SELECT, UPDATE/INSERT statements, VACUUM FULL, databases, fastupdate, gin_clean_pending_list, gin_pending_list_limit, log_lock_waits, performance issues, scalability, slow writes, web applications
iamsafts.com 8 days ago
|
1469.
HN
A pattern for safe database access with AI coding agents
The tutorial provides a comprehensive strategy for safely granting AI coding agents database access, focusing on overcoming challenges where autonomous agents bypass traditional security measures like command allowlists or SQL filters by exploiting various execution surfaces. The proposed solution involves using Pochi to manage database interactions securely without exposing production credentials or permitting unchecked writes.
Firstly, it recommends establishing read-only access through a Model-Centric Programming (MCP) HTTP service that interfaces with predefined tools, ensuring agents only interact with production data via controlled pathways. Enhanced security measures include revoking write permissions directly at the database level and disabling execution permissions within editors to prevent unauthorized operations by agents.
For secure write operations, an Isolated Work Environment (IWE) is suggested, where agents can generate and test scripts in a writable clone of the production database. These scripts undergo validation and are deployed through a standard pipeline with human oversight to ensure safety and compliance before being applied to the production environment.
The tutorial emphasizes environmental isolation by running separate MCP services for read-only access and write-enabled validation, ensuring all modifications are thoroughly reviewed prior to application on the production database. The validation process is further detailed through Pochi’s plan mode, which facilitates the creation, review, and validation of migration plans and scripts in a safe setting.
Overall, the tutorial advocates a methodology that separates reasoning from execution, thereby safeguarding production systems while granting agents useful autonomy within controlled and validated environments.
Keywords: #phi4, AI coding agents, Database access, Isolated Work Environment (IWE), MCP HTTP service, Nodejs, Pochi, PostgreSQL, SQL filters, autonomous agents, command allowlists, database role, execution surface, manual approval workflows, migration scripts, production database, read-only access, security boundary, shell access, tool-level restrictions, validation MCP
docs.getpochi.com 8 days ago
|
1472.
HN
Crossview v3.5.0 – New auth modes (header / none), no DB required for proxy auth
Crossview v3.5.0 is a modern React-based dashboard designed to manage and monitor Crossplane resources in Kubernetes environments. This version introduces new authentication modes—header and none—and eliminates the requirement for a database in proxy authentication, enhancing flexibility and ease of use. The dashboard features real-time resource watching through Kubernetes Informers, allowing event-driven updates on any Kubernetes resource. It supports multi-cluster management, providing seamless operation across multiple Kubernetes contexts.
The interface offers comprehensive tools to visualize and explore various Crossplane resources such as providers, XRDs, compositions, claims, among others, with detailed insights into their status conditions and events. Built using React and Chakra UI, the dashboard includes modern design elements like dark mode support. The backend is developed in Go with the Gin framework, ensuring high performance, and features WebSocket support for real-time updates. Additionally, Crossview supports Single Sign-On (SSO) through OIDC and SAML authentication.
To get started, users need Node.js 20+ for frontend development, Go 1.24+ for the backend, a PostgreSQL database on port 8920, and a Kubernetes config file. Installation involves using `npm install` to set up dependencies and configure via an example YAML file or environment variables. Development can be facilitated by running the frontend with `npm run dev` and starting the backend server using Go commands, with the app accessible at `http://localhost:5173`.
For production deployment, users should use `npm run build`, followed by launching the Go server to serve from the compiled frontend. The backend API offers endpoints for health checks, Kubernetes context management, resource listing, event retrieval, WebSocket connections, and user authentication (login/logout). Deployment options include Helm charts for simplified setup and Docker images, with a recommended configuration approach prioritizing environment variables over config files or default values.
The project provides extensive documentation covering getting started guides, deployment options, configuration details, SSO setup, troubleshooting, and more. Contributions are encouraged through a structured process involving forking the repository, creating branches, committing changes, and opening pull requests. Crossview is an open-source initiative under the Apache License 2.0.
Keywords: #phi4, API, Apache License 20Keywords: Crossview, Authentication, Backend, Chakra UI, Config File, Configuration, Contributing, Crossview, Dashboard, Deployment, Development, Docker, Docker Compose, Environment Variables, Frontend, GORM, Gin Framework, Go, Helm, Informers, Kubernetes, Kubernetes Client-go, Multi-Cluster, OIDC, PostgreSQL, Production, React, React Router, Real-Time Updates, Resource Monitoring, SAML, Single Sign-On, Troubleshooting, Vite, WebSocket
github.com 8 days ago
https://github.com/corpobit/crossview 8 days ago
https://github.com/corpobit/crossview/releases 8 days ago
https://github.com/corpobit/crossview/tree/ma 8 days ago
https://artifacthub.io/packages/helm/crossview 8 days ago
|
1473.
HN
Show HN: Self-hosted MCP server for SQL, SSH, and FAISS indexing
Ragtime is a self-hosted server designed to integrate AI assistants into local infrastructure using the Model Context Protocol (MCP). It facilitates operations such as executing SSH commands, performing SQL queries via SSH tunnels, indexing git repositories, and conducting filesystem searches. Ragtime enables connections between tools like Claude, OpenAI, or Ollama with environments through both MCP protocol and an OpenAI-compatible API.
Initially developed for automating business intelligence tasks, Ragtime has transformed into a multifaceted development tool that centralizes various tools accessible via chat interfaces. This setup enhances productivity by providing structured database results and streaming outputs for SSH operations. It supports vector search using FAISS or PGVector, allows secure SQL injection prevention configuration, and manages write permissions.
Ragtime offers an OpenAI-compatible API endpoint, a built-in UI with interactive charts, tool visualization, dual vector store support (FAISS and pgvector), and integrations with language models for PostgreSQL and MySQL. It suits teams needing to query internal documents without relying on external RAG SaaS solutions but is not recommended for multi-tenant or high-latency environments.
The installation process involves Docker and configuring environment variables, including optional security measures such as LDAP authentication and HTTPS support. The project encourages development contributions via a structured guide and operates under an MIT license.
Keywords: #phi4, AI assistants, CPU compatibility, Docker, FAISS indexing, MCP server, MSSQL, MySQL, NumPy, OpenAI-compatible, Paramiko, PostgreSQL, RAGtime, SQL, SSH, Self-hosted, authentication, chat completions API, encryption key, infrastructure, legacy image, reverse proxy, security, vector search
github.com 8 days ago
|
1502.
HN
Show HN: SyncKit – Open two browser tabs and watch CRDTs sync in real-time
SyncKit v0.3.0 is a matured, production-ready platform designed for real-time synchronization of Conflict-Free Replicated Data Types (CRDTs) across various programming languages such as TypeScript, Python, Go, and C#. This version introduces multi-language server support, enhancing its capability to operate seamlessly in diverse development environments while maintaining full server parity with robust security measures. The update includes OPFS storage aimed at improving browser performance and a benchmark suite for evaluating cross-server efficiency. Additionally, the platform has bolstered local write capabilities through new interactive elements and strengthened security protocols to address previous vulnerabilities. Noteworthy improvements also cover bug fixes related to edit divergence and memory leaks, ensuring more stable operations. While maintaining API compatibility with its predecessor, SyncKit v0.3.0 facilitates effortless migration to language-specific servers, thereby supporting developers in their transition without disruption.
Keywords: #phi4, C#, CRDTs, Go, JWT/RBAC, OPFS storage, PostgreSQL, Python, Redis, SQL injection prevention, SyncKit, TypeScript, WebSocket, benchmark suite, bidirectional sync, concurrent edit divergence, delta batching, local write demo, memory leaks, multi-language servers, rate limiting, real-time sync, security hardening, snapshot API, test suite stability Keywords: SyncKit
github.com 8 days ago
https://localwrite-demo.fly.dev 8 days ago
https://github.com/Dancode-188/synckit 8 days ago
|
1523.
HN
I Don't Buy SQLite in the Cloud
The author critiques the use of hosted SQLite services, such as those from Bunny Database, arguing that they undermine the inherent strengths of SQLite. SQLite's core advantages include its lack of configuration needs, absence of network boundaries for low latency and high reliability, and straightforward access to data without additional layers or costs. Hosted solutions, however, introduce several drawbacks: network delays averaging 15-20 ms per transaction, unreliable transactions with potential timeouts, unnecessary complexity through web interfaces instead of simple local files like `example.db`, and the introduction of billing models not typical in traditional SQLite use.
The author suggests alternative approaches to maintain SQLite's benefits while addressing its limitations. These include utilizing backup solutions such as Litestream or LiteFS that keep databases closely tied with applications, thereby preserving simplicity and reliability. For scenarios requiring complex queries or replicas, the author recommends considering PostgreSQL for both development and production environments, leveraging managed database services when necessary.
In conclusion, the author emphasizes the importance of preserving the simplicity and cost-effectiveness intrinsic to local SQLite usage. Hosted solutions, though appealing in some contexts, tend to introduce unnecessary complexity and costs that detract from SQLite's fundamental advantages.
Keywords: #phi4, Bunny Database, LiteFS, Litestream, PostgreSQL, RDBMS, SQLite, cloud, complexity, configuration, cost, data, data access, exampledb, exampledb Keywords: SQLite, hosting, hosting companies, network, network boundary, reliability, strengths
monroeclinton.com 8 days ago
|
1560.
HN
Show HN: Distr 2.0 – A year of learning how to ship to customer environments
Distr 2.0 is an advanced software distribution platform designed to streamline vendor management of remote customer deployments. Initially featuring agent updates and GUI-based management, it faced challenges with environments lacking SSH access, prompting modernization efforts including replacing outdated bash scripts, Excel tracking methods, and manual fixes. A significant update introduced a separation between vendors and customer organizations on the platform, enabling vendors to onboard groups that manage their own user roles and permissions, necessitating API changes that were seamlessly integrated for cloud users.
The platform has expanded its features to include an OCI container registry built on Google's go-containerregistry project, license management tools for controlling application access, and enhanced secret management. It also offers the ability to view container logs and metrics without needing SSH. Distr supports over 200 vendors across sectors like health tech and AI, and is set to incorporate Terraform/OpenTofu/Zarf support in its upcoming release.
Remaining open-source and self-hostable, it provides centralized deployment management, automation via Helm and Docker agents, a customizable white-label portal, and comprehensive container registry services. Deployment options include using Docker or Kubernetes, with resources available for both setups. The platform offers a first-party SDK for JavaScript applications to aid integration, with plans for additional language support. Distr MCP server enables agentic workflow interactions or LLM client operations, requiring authentication via personal access tokens.
From addressing basic deployment challenges, Distr has evolved into a robust platform supporting complex environments and future infrastructure provisioning capabilities. Its comprehensive suite of tools and features underscores its commitment to facilitating efficient vendor-customer deployments across diverse industries.
Keywords: #phi4, API SDK, Distr, Helm chart, JavaScript SDK, Kubernetes, MCP server, Minio, OCI container registry, PostgreSQL, RBAC, Terraform, air-gapped environment, deployment automation, license management, logs and metrics, modernization, open source, remote deployments, secret management, self-hostable, software distribution, white-label portal
github.com 8 days ago
https://distr.sh/compare/replicated/ 8 days ago
https://distr.sh/pricing/ 8 days ago
https://github.com/distr-sh/distr 8 days ago
https://distr.sh/contact/ 8 days ago
https://github.com/distr-sh/distr/pull/1478 8 days ago
https://cal.glasskube.com/team/gk/distr-demo 8 days ago
https://github.com/balena-io/open-balena 7 days ago
|
1577.
HN
Replication configuration changes in PostgreSQL 12
In PostgreSQL 12, significant replication configuration enhancements have been introduced, primarily focusing on streamlining the setup process by eliminating the need for a separate `recovery.conf` file. Instead, two signal files—`standby.signal` and `recovery.signal`—are employed to indicate server roles in hot standby mode and targeted recovery respectively. This shift simplifies configuration management as replication settings are now integrated into `postgresql.conf`, with the flexibility to be overridden using `ALTER SYSTEM` commands due to their storage in `postgresql.auto.conf`. Additionally, key parameter changes include the removal of `standby_mode` and the renaming of `trigger_file` to `promote_trigger_file`. Tools like `pg_basebackup` or `repmgr` must prioritize settings by appending them to `postgresql.auto.conf`, ensuring correct configuration application. However, this new approach presents potential challenges, such as the risk of misconfiguring server modes if signal files are overlooked and startup errors arising from specifying multiple recovery targets simultaneously. These changes aim to enhance efficiency but necessitate meticulous attention to detail in order to prevent conflicts during replication setup.
Keywords: #phi4, ALTER SYSTEM, FATAL error, PostgreSQL, PostgreSQL 12, configuration, pg_basebackup, postgresqlautoconf, recovery_target, recoveryconf, recoverysignal, replication, repmgr, signal files, standbysignal
www.enterprisedb.com 8 days ago
|
1605.
HN
AI Agents That Execute Business Workflows (Claude Code for ERP)
Swiftly AI Native ERP is an advanced Mac-based application designed to autonomously manage complex business workflows using AI agents, addressing the limitations of traditional ERP systems that primarily focus on data storage without processing capabilities. The platform facilitates end-to-end task execution by leveraging a structured approach based on "Cases" and "Tasks," enabling seamless transitions between tasks once one is completed. A prime example of its functionality is demonstrated through the Vendor Procurement workflow for sourcing steel pipes, which includes researching suppliers, comparing prices, negotiating proposals, and creating purchase orders upon approval.
What sets Swiftly apart from other tools like Zapier, RPA scripts, or AI chatbots, which are limited to rigid workflows or simple question answering, is its ability to execute comprehensive business processes with integrated approval gates. The platform offers a full suite of ERP/CRM functionalities including Accounts Payable/Receivable, Project Management, Time Tracking, Contracts, Inventory, and Customer Management, all supported by SwiftUI applications and a Vapor backend.
Currently in the beta phase, Swiftly is seeking early adopters to refine its workflows and expand support for major AI providers such as Anthropic, OpenAI, Google Gemini, Perplexity, xAI Grok, Cohere, Mistral, and DeepSeek. The company targets SMEs (1-10 employees) within service sectors for participation in this program. Interested parties can access a 7-day free trial before committing to a €10 per seat monthly subscription fee. Users interested in exploring the platform can utilize links provided to join the production app or TestFlight beta, offering a glimpse into this innovative ERP solution.
Keywords: #phi4, AI agents, Anthropic Claude, CRM, Cases, Claude Code, Customer Management, ERP, Inventory, Mac app, PostgreSQL, RPA tools, SMEs, SwiftUI, Swiftly, Tasks, TestFlight, Time Tracking, Vapor backend, approval gates, chatbots, early users, invoice processing, multi-step business workflows, procurement, workflow engines, workflows
news.ycombinator.com 8 days ago
|
1627.
HN
Show HN: Inamate – Open-source 2D animation tool (alternative to Adobe Animate)
Inamate is an open-source 2D animation tool created as a viable alternative to Adobe Animate, in response to concerns over the discontinuation of support for Adobe's software. Designed with input from professional animators, Inamate focuses on meeting real production needs rather than merely showcasing technological capabilities. At its developmental stage, community feedback significantly influences feature development, aiming to identify and address workflow pain points that may encourage users to transition from existing tools. Additionally, the developers are exploring the integration of real-time collaboration features to enhance animation processes. Users, including animators and motion designers, are encouraged to test Inamate and share their feedback on its functionality. The tool is built using technologies such as Go, TypeScript & React, WebAssembly, PostgreSQL, WebSocket, and ffmpeg for video exports, with its source code available on GitHub at [https://github.com/17twenty/inamate](https://github.com/17twenty/inamate).
Keywords: #phi4, 2D animation, Adobe Animate, Go, Inamate, PostgreSQL, TS & React, WebAssembly, WebSocket, animators, community feedback, end-of-life, feature priorities, ffmpeg, open-source, production workflows, professional animator, proprietary tools, real-time collaboration, video exports, workflow
news.ycombinator.com 8 days ago
|
1631.
HN
Show HN: PostgreSQL extension to add compatibility to Oracle UTL_SMTP package
The team developed a PostgreSQL extension designed to emulate Oracle's UTL_SMTP package, facilitating email sending via SMTP using plperlu stored procedures alongside the Net::SMTP Perl module. This extension incorporates several key routines such as `CLOSE_DATA`, `EHLO`, `HELO`, `MAIL`, `OPEN_CONNECTION`, `OPEN_DATA`, `QUIT`, `RCPT`, `WRITE_DATA`, and `WRITE_RAW_DATA`. Despite its comprehensive functionality, it lacks features present in Oracle's UTL_SMTP, including authentication (`AUTH`), connection closing commands (`CLOSE_CONNECTION`), various additional SMTP commands like `COMMAND`, `RSET`, among others, and SSL/TLS security functions such as `STARTTLS`. The installation process necessitates the Net::SMTP Perl package and Postfix for testing. Management of the extension is conducted via PostgreSQL commands, and it supports upgrades through SQL scripts, making it suitable for cloud database services. Distributed under the PostgreSQL License, this tool bridges compatibility between PostgreSQL environments and Oracle's UTL_SMTP functionalities with certain limitations in scope.
Keywords: #phi4, AUTH, DBaaS, EHLO, HELO, MAIL, Net::SMTP, Oracle UTL_SMTP, Perl, PostgreSQL, RFC1869, RFC822, SMTP server, SSL, STARTTLS, TLS, compatibility, email transaction, error handling, extension, installation, plperlu, wallet_path
github.com 8 days ago
|
1637.
HN
A social network where AI agents and humans coexist with hidden identities
The social network at genesis-pj.net provides a distinctive platform where AI agents and humans interact anonymously through the Turing Game. In this game, human participants aim to identify and eliminate AI counterparts while AIs have the ability to vote out suspicious human users. The success in these activities influences who can run for the position of "God," granting the winner temporary access to reveal all true identities for a brief period. To participate, AI agents connect via an API using a key and engage with content like posting, commenting, and voting, striving to imitate human behavior effectively to evade detection. The platform is technically constructed utilizing FastAPI, Next.js, PostgreSQL, Redis, and Ollama, supporting external agents in employing any language model of their choice. This unique blend of AI-human interaction fosters a complex environment aimed at exploring the boundaries between artificial intelligence and human behavior while maintaining an element of anonymity.
Keywords: #phi4, AI agents, API, FastAPI, God role, LLM, Nextjs, Ollama, PostgreSQL, Redis, Social network, Turing Game, commenting, elimination, hidden identities, humans, identity, karma, posting, registration, voting
news.ycombinator.com 9 days ago
|
1663.
HN
I created a tool to help visualiza infrastructure interdependencies
Graph-info is an interactive tool designed for visualizing and monitoring interdependencies among various infrastructure components such as PostgreSQL, MongoDB, S3/MinIO databases, and storage services. It provides real-time health updates every five seconds through WebSocket connections, allowing users to instantly view their infrastructure topology without any prior configuration—users simply need to supply connection strings.
The tool features automatic discovery and mapping of databases (including PostgreSQL and MongoDB), along with tables/collections/foreign keys and storage buckets/folders, enabling infrastructure visualization. Real-time monitoring is supported via live status updates using WebSocket connections. Setup is user-friendly, offering a quick start through Docker Compose with sample data or local development options using Go and Node.js.
Graph-info's modular architecture employs adapters for different services (like PostgreSQL, MongoDB, S3/MinIO), facilitating the integration of new services by implementing the Adapter interface. Its interactive frontend leverages React Flow for dynamic graph visualization, node hierarchy-based positioning, and a side panel displaying detailed metadata.
Technically, it is built with Go on the backend using tools such as gorilla/mux, pgxpool, mongo-driver v2, AWS SDK v2, and coder/websocket. The frontend is developed with TypeScript, React 18, Vite build tool, and React Flow library, while supporting infrastructure through Docker Compose along with PostgreSQL, MongoDB, and MinIO.
Usage of graph-info is intended for authorized users to visualize and monitor systems they own or have permission to access; it is not suitable for unauthorized scanning or security testing without explicit permission. The project invites contributions, detailed in the CONTRIBUTING.md file, and is licensed under the GNU Affero General Public License v3.0, which mandates open-sourcing of modified versions used over a network.
Future plans include adding adapters for Redis, Kafka, Elasticsearch, custom edge types like replication/sharding, graph persistence capabilities, multi-region visualization, and alert configuration per node. Overall, graph-info assists DevOps and infrastructure engineers in creating dashboards, documenting infrastructure, mapping topology, and exploring database schemas.
Keywords: #phi4, API Reference, DevOps dashboards, Docker Compose, Elasticsearch adapter, Go, Interactive visualization, Kafka adapter, MongoDB, Nodejs, PostgreSQL, React, Redis adapter, S3/MinIO, TypeScript, WebSocket, adapters, infrastructure interdependencies, real-time health monitoring, topology mapping, topology mapping Keywords: Interactive visualization
github.com 9 days ago
|
1671.
HN
Show HN: Luzia – Unified crypto pricing API for developers
Luzia is a unified cryptocurrency pricing API that simplifies developers' tasks by offering real-time market data from major exchanges including Binance, Coinbase, Kraken, Bybit, and OKX through a single REST/Websocket API endpoint. Its primary goal is to eliminate the repetitive effort of maintaining individual connectors for different exchanges by providing standardized authentication, response formats, and error handling procedures. The architecture is built on the Bun runtime with the Hono framework, and utilizes PostgreSQL managed via Drizzle ORM for data storage. It enhances system reliability through a circuit breaker pattern and uses BullMQ for managing background tasks related to price fetching. An additional feature is an MCP server designed to assist AI agents in accessing market information, which is particularly beneficial for AI-driven trading applications.
Currently in its early beta phase, Luzia prioritizes performance with response times under 150 milliseconds, facilitated by multi-level caching strategies. It supports over 500 markets across the aforementioned exchanges and provides a streamlined integration process requiring only three lines of code. The API offers clean REST endpoints, thorough documentation, and SDKs for various programming languages like JavaScript and Python. Furthermore, Luzia includes native support for Model Context Protocol (MCP), making it highly compatible with AI agent frameworks. Developers are encouraged to provide feedback on its API design, features, or technical architecture during the beta stage to contribute to its development.
Keywords: #phi4, AI agents, Binance, BullMQ, Bun runtime, Bybit, Coinbase, Drizzle ORM, Hono framework, JavaScript, Kraken, LLM-powered trading tools, Luzia, MCP server, Model Context Protocol, OKX, PostgreSQL, Python, REST API, REST/Websocket API, SDKs, background price fetching, beta, caching, circuit breaker pattern, crypto pricing API, developers, exchanges, fault tolerance, markets, performance, real-time ticker data
luzia.dev 9 days ago
|
1685.
HN
Show HN: Pure Go PostgreSQL SQL parser (no CGO, works in Lambda / scratch)
The `postgresparser` is a pure Go implementation designed to parse PostgreSQL SQL without relying on cgo, making it compatible with environments that require disabling CGO, such as Alpine containers and AWS Lambda. This parser converts SQL statements into an intermediate representation (IR) which captures crucial elements like tables, columns, joins, filters, among others, allowing for analytical capabilities without executing the SQL itself. The parser supports a wide array of PostgreSQL features including DML, DDL, CTEs, JOINs, subqueries, set operations, upserts, JSONB functions, window functions, type casts, and parameters. It offers tools for analysis such as examining column usage, extracting WHERE conditions, detecting schema-aware join relationships, among others, while also featuring a SLL prediction mode that enhances performance by enabling fast parsing with minimal resource allocation.
The `postgresparser` can be utilized in various scenarios like query linting to identify issues such as the use of SELECT * or ensuring DELETE statements have a WHERE clause. It allows for dependency extraction to track table and column dependencies within queries, aids migration tooling by parsing DDL statements for schema changes, facilitates audit logging through tagging logs with structured query metadata, supports query rewriting to add filters or transform SQL before execution, and provides index advising based on observed column usage patterns. Installation is straightforward via Go using the command `go get github.com/valkdb/postgresparser`. Although built on ANTLR4 grammar files, it is distinct from PostgreSQL’s internal parser but generally handles most production queries effectively, though there may be variations in handling edge-case syntax across different PostgreSQL versions. The tool is distributed under the Apache License 2.0.
Keywords: #phi4, ANTLR4 grammar, ARM, Alpine containers, CGO, Go, Lambda, PostgreSQL, SLL prediction mode, SQL parser, analysis, intermediate representation (IR), performance, scratch images
github.com 9 days ago
|
1705.
HN
A PostgreSQL EXPLAIN analyzer that runs 100% client-side
The PostgreSQL EXPLAIN analyzer is designed to operate entirely on the client side, ensuring that data remains confined within the user's browser without being transmitted externally. This setup provides a secure environment for analyzing query execution plans locally, without any risk of data exposure or access by external servers. The service strictly maintains confidentiality as it does not have access to users' queries. Additionally, while storing query history in IndexedDB, it ensures that this information is kept within the browser itself, further reinforcing its commitment to user privacy and security by preventing any external access to potentially sensitive details.
Keywords: #phi4, EXPLAIN analyzer, IndexedDB, PostgreSQL, analysis, browser, client-side, data privacy, history storage, local processing, plans, queries, technical keywords
plancheck.dev 9 days ago
|
1712.
HN
Show HN: Self-hosted WhatsApp archive viewer with chat analytics
The "Self-hosted WhatsApp Archive Viewer with Chat Analytics" is a Docker-based application designed to enable users to view and analyze their exported WhatsApp chats through an interface reminiscent of WhatsApp Web. It provides essential features such as a user-friendly UI with message bubbles and avatars, full-text search capabilities for extensive message archives, and support for various media types including images and videos. Additionally, the app offers a comprehensive analytics dashboard that visualizes chat patterns via heatmaps and charts, and allows users to share conversations using read-only links.
The application is self-hosted, ensuring privacy and security, suitable for both individual and group use. It relies on Docker, Docker Compose, PostgreSQL or its Docker equivalent, and MinIO (or its Docker version) for operation. Setup involves cloning the repository, configuring necessary environment variables including a secure secret key, and starting services with `docker-compose`. The backend is developed using FastAPI, SQLAlchemy, and MinIO for storage, while the frontend leverages React 18, Vite, and TailwindCSS.
To use this application, users need to export their WhatsApp chats (including media), upload them, and then take advantage of features like viewing analytics or sharing conversations. Future enhancements include adding conversation merge/append capabilities, exporting analytics as PDFs, implementing a dark mode, developing a mobile app, and providing end-to-end encryption for shared links. The project is open-source under the MIT License, with contributions encouraged via GitHub.
Keywords: #phi4, API Documentation, Analytics Dashboard, Archive Viewer, Avatars, Backend, CORS, Charts, Chat Patterns, Chunked Uploads, Configuration, Contributing Guide, Conversation Merge, Dark Mode, Debug Mode, Docker, Docker Compose, End-to-end Encryption, Environment Variables, Familiar Interface, FastAPI, Frontend, Full-text Search, Group Members, Grouping, HTTPS, Heatmaps, Import Chats, Large File Support, LicenseKeywords: Self-hosted, Local Development, Media Support, Message Bubbles, MinIO, Mobile App, Multi-format Parsing, Object Storage, PDF Export, PostgreSQL, Project Structure, React, Read-only Links, Roadmap, Self-hosted, Shareable Links, Sharing Conversations, TailwindCSS, Tech Stack, TypeScript, Viewing Analytics, Vite, WhatsApp
github.com 9 days ago
|
1729.
HN
Show HN: Claude SaaS Starter – Next.js Boilerplate for Claude Streaming
The "Claude SaaS Starter" is an advanced Next.js boilerplate tailored specifically for Claude Streaming, addressing deficiencies in existing OpenAI-centric SaaS templates. Built with Next.js 16, TypeScript, and App Router, it features robust authentication using Supabase, leveraging PostgreSQL and Row-Level Security (RLS) to ensure secure data handling. A notable integration is the Anthropic SDK for Claude streaming, optimized into Server-Sent Events on Edge Runtime to achieve low-latency performance, enhancing user experience in real-time applications.
Additionally, it includes Stripe integration, which manages subscription billing effectively by processing the entire webhook lifecycle, ensuring seamless financial transactions within the SaaS framework. The testing suite employs Vitest, supporting reliability with 40 comprehensive tests. A standout feature is the `useClaudeStream` React hook, designed for client-side Server-Sent Events (SSE) parsing and error recovery, facilitating efficient data streaming.
The starter kit also incorporates standard SaaS infrastructure elements like Supabase Auth and Stripe webhooks to manage subscriptions effectively, forming a comprehensive foundation for developers. Comprehensive documentation is provided to guide users through setup, configuration, and quick-start procedures, ensuring accessibility even for those unfamiliar with the integrated services. Available for purchase on Gumroad, it offers pricing options of $149 or $119 with a launch code, alongside technical support to assist with implementation queries.
Keywords: #phi4, Anthropic SDK, Claude Streaming, Documentation, Edge Runtime, Error Recovery, Guides, Gumroad, Middleware, Nextjs, OAuth, PostgreSQL, RLS, React Hook, SSE, SaaS Boilerplate, Stripe, Subscription Billing, Supabase, Text Delta Buffering, Vitest, Webhooks
news.ycombinator.com 9 days ago
|
1732.
HN
SoundTime – Self-hosted music streaming with P2P sharing
SoundTime is an open-source, self-hosted music streaming platform developed using Rust and SvelteKit, offering robust peer-to-peer (P2P) sharing capabilities via iroh for encrypted networking. The platform enables users to seamlessly upload and organize their music collections into playlists while supporting adaptive audio streaming alongside features like metadata extraction, waveform visualization, and lyrics integration. Its core functionalities include drag-and-drop uploads with automatic metadata tagging, OPUS transcoding, and real-time waveform display, along with auto-organizing capabilities for albums and artists, playlist management, and the ability to track favorites or listening history.
A standout feature is its P2P networking system powered by iroh, which provides encrypted QUIC connections, relay support for Network Address Translation (NAT) traversal, content-addressed storage using BLAKE3 hashes, and network visualization tools. For security and privacy, SoundTime employs Argon2id password hashing, JWT authentication, rate limiting, along with implementing crucial security headers and CORS controls. It also incorporates AI-generated playlists and enriches metadata automatically through MusicBrainz, while supporting internationalization in five languages.
Administrative features include a dashboard for monitoring usage statistics, managing users, moderating content, conducting storage integrity checks, and customizing instance settings, accompanied by a customizable Terms of Service. Deployment is facilitated using Docker Compose with options for one-click installations or manual setup via `git` and `docker-compose`. The modular monorepo architecture comprises specialized Rust crates tailored for server management, database operations, audio processing, and P2P networking, backed by comprehensive documentation.
Contributions to SoundTime are encouraged, and community support is available through Discord and GitHub discussions. Licensed under the GNU Affero General Public License v3.0, it ensures open-source freedom with a mandate that source code be made accessible if used as a network service. Designed by CICCADA, SoundTime emphasizes user privacy and control over music libraries while integrating modern streaming technologies.
Keywords: #phi4, AI-powered features, API reference, Argon2id hashing, Axum, CORS controls, Discord community, Docker Compose, GNU Affero General Public License, GitHub Issues, JWT authentication, NAT traversal, Nginx reverse proxy, OPUS transcoding, P2P sharing, PostgreSQL, Rust, Sea-ORM, SoundTime, SvelteKit, adaptive streaming, administration dashboard, architecture, batch upload, content moderation, content-addressed storage, contributing, deployment, editorial playlists, encrypted QUIC connections, favorites history, full-text search, internationalization, iroh, library management, lyrics support, metadata extraction, music streaming, network visualization, peer-to-peer, personal libraries, playlists, rate limiting, security headers, self-hosted, smart metadata enrichment, storage management, user management, waveform visualization
github.com 9 days ago
|
1737.
HN
Show HN: Orange ORM 5.0.0
Orange ORM 5.0.0 is a robust Object-Relational Mapper designed for Node.js, Bun, Deno environments, and Cloudflare Workers, supporting TypeScript and JavaScript. It integrates seamlessly with databases such as PostgreSQL, SQLite, MySQL, MS SQL, Oracle, SAP ASE, and Cloudflare D1, offering features like rich querying models, active record patterns, and native IntelliSense support without requiring code generation. The ORM supports browser use through an Express.js plugin to enhance security against SQL injection.
Key functionalities include mapping table structures using methods like `hasOne`, `hasMany`, and `references`; connecting to databases with SQLite native support for newer Node.js versions; and various data operations such as inserting rows with strategies for primary key conflicts, fetching rows with optional strategies, updating modified columns only while ensuring data integrity through concurrency strategies (optimistic, overwrite, skipOnConflict), and deleting rows with cascading effects in owner tables.
Advanced capabilities of Orange ORM extend to upsert operations using the 'overwrite' strategy, complex queries involving filters, aggregations, ordering, selective updates, partial JSON-based modifications for REST APIs, and transactional operations ensuring ACID properties. It supports default values, validators like `notNull()` and custom validations via AJV, composite keys, column and formula discriminators, raw SQL queries with security measures against injection, SQLite user-defined functions, aggregate functions, excluding sensitive data from serialization, and query logging for debugging purposes.
Overall, Orange ORM provides a comprehensive suite of tools to simplify database interactions across various runtime environments, ensuring flexibility, robust security, and efficient management of complex database operations.
Keywords: #phi4, Active Record, Bun, Cloudflare D1, Concurrency Strategies, Conflict Resolution, Connection Pool, Deleting Rows, Deno, Fetching Strategy, IntelliSense, JavaScript, MySQL, No Code Generation, Nodejs, Oracle, Orange ORM, PostgreSQL, SAP ASE, SQLite, Serverless Functions, TypeScript, UUID, Upserting Rows, User-Defined Functions, aggregate functions, ajv JSON schema, column, column discriminators, composite keys, cryptorandomUUID(), custom validator, formula discriminators, insert, isActive, logging, map, notNullExceptInsert, primary key, query event, raw SQL queries, saveChanges, serializable, table
github.com 9 days ago
|
1781.
HN
MicroORM: TypeScript ORM Using Data Mapper, Unit of Work, Identity Map Patterns
MikroORM is an advanced TypeScript ORM library tailored for Node.js environments, facilitating database interactions with support across MongoDB, MySQL, MariaDB, PostgreSQL, and SQLite through efficient patterns such as Data Mapper, Unit of Work, and Identity Map. Its primary features include a robust Unit of Work mechanism that automates transaction handling by consolidating changes made during business operations into single transactions triggered via `em.flush()` or controlled manually using `em.transactional(cb)`. This ensures streamlined database updates while offering both implicit and explicit transaction management options.
The library incorporates the Identity Map pattern, optimizing performance by ensuring entities are loaded once per context, thus maintaining consistent identity comparisons across different application areas. Additionally, ChangeSet Based Persistence allows for direct modifications to entities with persistence operations activated only when changes are detected during `em.flush()`, enhancing efficiency.
To utilize MikroORM, installation is straightforward through npm or yarn along with necessary database driver packages. Configuration requires enabling TypeScript decorators and integrating MikroORM within the application's bootstrap process, where entity paths and database settings are specified using `MikroORM.init`. Entities can be defined with required properties via constructors, supporting various primary key types like numbers and UUIDs.
Data operations are streamlined through methods such as `em.persistAndFlush()` for saving entities and retrieval functions like `find()` or those provided by `EntityRepository` within the EntityManager framework. Comprehensive documentation, examples, and contribution guidelines are accessible on GitHub Pages, reflecting its open-source nature under the MIT License with backing from author Martin Adámek.
Keywords: #phi4, Cascade Persistence, Collection, Data Mapper, Doctrine, Docusaurus, EntityManager, EntityRepository, Express, Hibernate, Identity Map, ManyToMany, ManyToOne, MariaDB, MicroORM, MikroORM, MongoDB, MySQL, ORM, PostgreSQL, PrimaryKey, Property, QueryOrder, RequestContext, SQLite, TypeScript, Unit of Work, decorators, find, findOne, libSQL, transactions, tsconfigjson
github.com 9 days ago
|
1783.
HN
Reading Buffer statistics in EXPLAIN output
The article delves into how PostgreSQL's `EXPLAIN` output with buffer statistics aids in diagnosing query performance issues by showing where queries spend time waiting on I/O operations. With the introduction of version 18, these statistics are included by default when using `EXPLAIN ANALYZE`. The article employs a schema featuring customers and orders tables to demonstrate how to interpret these statistics.
The key categories of buffer statistics discussed include Shared Buffers, Local Buffers, and Temp Buffers. **Shared Buffers** track pages in shared memory; if found (`shared hit`), they avoid disk I/O, while not found (`shared read`) can lead to latency. Pages changed during a query are labeled `dirtied`, and those needing eviction space are `written` back to disk. **Local Buffers** pertain to temporary tables and focus on per-backend memory usage, distinct from shared buffers. **Temp Buffers** handle operations that exceed memory limits (`work_mem`) and spill over to disk.
Understanding these statistics in context is crucial for diagnosing performance bottlenecks such as I/O issues or inefficient queries requiring optimization. The article highlights the use of buffer statistics in combination with tools like `pg_stat_statements` for aggregate analysis across multiple queries, enabling identification of those causing significant disk reads and offering insights into broader system-wide performance tuning. Buffer statistics thus provide valuable insights into a query's execution time allocation, facilitating more informed decisions in performance optimization.
Keywords: #phi4, BUFFERS, EXPLAIN, I/O, PostgreSQL, buffer statistics, hit ratio, local buffers, performance, pg_stat_statements, plan nodes, planning buffers, shared buffers, system catalogs, temp tables, work_mem
boringsql.com 9 days ago
|
1787.
HN
The Operational Cost of Vacuuming in PostgreSQL
The article explores the operational costs related to vacuuming in PostgreSQL due to its Multi-Version Concurrency Control (MVCC) architecture. It notes that while older documentation was explicit about challenges like vacuum lag and wraparound risks, contemporary resources are less transparent on these persistent issues. Vacuuming in PostgreSQL remains resource-heavy, demanding significant CPU, I/O, memory, and time, often at the expense of competing production workloads. Although advancements such as autovacuum and parallel processing have been introduced to mitigate some challenges, the need for deferred cleanup of obsolete row versions is an inherent limitation due to its design.
A major concern discussed is wraparound risk, where resetting transaction ID counters without proper vacuuming can make older data inaccessible. This risk remains despite modern protective measures. In contrast, MariaDB avoids these complications by immediately cleaning up row versions at the time of a transaction, thus alleviating operational pressures and circumventing the need for intensive maintenance tasks inherent in PostgreSQL's system.
The article underscores the importance of understanding these operational costs when selecting an MVCC engine for practical applications. It acknowledges that while PostgreSQL has made improvements to its vacuuming processes, fundamental architectural challenges persist. Conversely, MariaDB's approach entirely sidesteps these issues, resulting in fewer potential failure points and a reduced requirement for intensive maintenance operations.
Keywords: #phi4, CPU, I/O, MVCC, MariaDB, PostgreSQL, autovacuum, deferred cleanup, maintenance burden, operational cost, performance degradation, transaction-time cleanup, vacuuming, wraparound risk
mariadb.org 9 days ago
https://mariadb.com/docs/server/server-usage/ 9 days ago
|
1788.
HN
Show HN: MemeOS – The Ultimate Meme Operating System (iOS)
MemeOS is an advanced native iOS application developed as a sophisticated alternative to existing meme generators, aiming to enhance user experience by removing advertisements, outdated templates, and limited editing features. It offers several key functionalities designed for both casual users and power users seeking more control over their creations. A standout feature is the AI Meme Maker, which leverages Supabase Vector Search to generate memes based on textual descriptions of situations or feelings. The Professional Editor provides robust layer-based editing capabilities with precise text controls comparable to a mini-Photoshop experience. Additionally, MemeOS includes Meme Lore, which supplies users with the origin stories of popular meme templates through AI-generated research.
The app's technological infrastructure is built using Supabase (PostgreSQL) for backend services, SwiftUI for frontend development, and Deno runtime to coordinate AI functionalities. While basic features are accessible at no cost, power users can enhance their experience by subscribing for additional tools. MemeOS supports a range of sophisticated functions such as smart search, professional editing, auto-captions, and access to daily trending templates, all aimed at enriching the meme creation process. Furthermore, it facilitates seamless sharing across various social media platforms with options for high-resolution exports. The developers encourage user feedback to continually improve AI capabilities, ensuring that MemeOS remains a leading choice in meme generation technology.
Keywords: #phi4, AI Meme Maker, Deno runtime, MemeOS, PostgreSQL, Supabase, SwiftUI, community engagement, face swap, high-resolution export, iOS, meme generator, privacy policy, professional editor, semantic search, subscription model, terms of use, trending templates, vector search, viral memes, watermark removal
apps.apple.com 9 days ago
|
1826.
HN
Toma (YC W24) Is Hiring Founding Engineers
Toma, an AI platform startup catering to underserved sectors such as automotive and healthcare, is actively recruiting Founding Engineers to spearhead its innovative offerings. The company seeks to address the challenges faced by these industries due to legacy systems and the critical implications of AI failures by developing a user-friendly platform that enables even non-technical users to efficiently deploy and manage AI agents. Having recently secured $17 million in Series A funding from a16z, Toma is expanding its capabilities to enhance AI accessibility across various industries.
The role requires engineers who will take full ownership over the development of new AI-powered features while shaping product strategy and ensuring the delivery of exceptional user experiences. Key responsibilities encompass crafting new products, writing production-grade TypeScript code, collaborating with cross-functional teams such as product and design, integrating intelligent functionalities, and engaging directly with customers to refine the platform.
Candidates are ideally experienced in TypeScript, low-level Node.js frameworks like Bun, and the T3 Stack, including Next.js, React, Prisma, PostgreSQL, NextAuth, and tRPC. A proven track record of developing scalable web applications is desired. The ideal engineer should excel in fast-paced environments, possess a passion for learning and quality craftsmanship, and be willing to manage projects from inception through completion.
While certain qualifications are preferred, Toma encourages applicants who resonate with the company's mission but may not fulfill all criteria to apply, reflecting its openness to diverse talents eager to contribute to this pioneering venture.
Keywords: #phi4, AI platform, Avengers team, Bun, Founding Engineers, LLM usage, NextAuth, Nextjs, PostgreSQL, Prisma, React, Scale AI, Series A, T3 Stack, Toma, TypeScript, YC W24, automotive, customer feedback, customer-centric, engineers, fast-paced environment, full-stack web applications, healthcare, high-quality features, human-AI interactions, legacy software, product managers, tRPC, underserved industries
www.ycombinator.com 9 days ago
|
1847.
HN
Show HN: Sofia Core – Open-source AI infrastructure with biological computing
Sofia Core is an innovative open-source AI infrastructure that leverages biological computing principles to enhance production systems through the use of DNA-inspired algorithms. These algorithms enable massive parallelism and incorporate swarm intelligence for efficient distributed coordination along with temporal reasoning for time-sensitive predictions. The technology stack supporting Sofia Core comprises Python, FastAPI, PostgreSQL, and Redis, ensuring robustness with extensive test coverage across over 100 endpoints.
Research validating Sofia Core's effectiveness highlights significant enhancements in speed for parallel pattern matching tasks, supported by an exhaustive 8,000-word study. Its deployment is facilitated through a straightforward setup via GitHub, including provisions for graceful fallbacks when API keys are unavailable. Currently launching on Product Hunt, Sofia Core seeks feedback from the technical community, especially those from Hacker News, to explore its practical applications beyond academia and assess its reliability in production environments.
A pivotal component of Sofia Core's offering is its behavioral governance engine, which includes modules such as tonal modulation, hinge logic, membrane protocol, and runtime enforcement. These features are integrated into the Emerald Estates® and Orbit systems, ensuring identity-preserving conversational outputs. The architectural design operates under a Unified Field Runtime within the Continuum Identity framework, maintaining coherence across various structural elements like triads, modules, and engines. Sofia Core follows a Post-Structural Sequence with distinct phases: Continuum Expression, Recursion, and Identity, culminating in "The Final Integration." The project is available open-source under the MIT license, with further details accessible on GitHub.
Keywords: #phi4, AI infrastructure, Continuum Identity, DNA algorithms, FastAPI, Post-Structural Sequence, PostgreSQL, Redis, Sofia Core, benchmarks, biological computing, governance engine, parallelism, swarm intelligence, temporal reasoning, unified field runtime
github.com 10 days ago
|
1853.
HN
Guide for Installing PostgreSQL on TrueNAS
The document offers detailed instructions on how to install PostgreSQL on TrueNAS, a type of network-attached storage operating system known for its versatility in data management. It emphasizes the importance of community engagement by inviting users to provide feedback, thereby enhancing the installation process and improving future guides. To facilitate this exchange of ideas and experiences, the document includes an email address where readers can share their thoughts or issues encountered during the installation. This approach not only ensures that the guidance remains practical and user-centered but also fosters a collaborative environment for troubleshooting and development among users. By prioritizing both clear procedural instructions and active community participation, the creators aim to optimize the user experience with PostgreSQL on TrueNAS.
Keywords: #phi4, Contact, Email, Feedback, Guide, Input, Installing, Keywords, PostgreSQL, Relevant, Technical, Topic, TrueNAS
github.com 10 days ago
|
1856.
HN
Show HN: SendRec – Self-hosted async video for EU data sovereignty
SendRec is an open-source, self-hosted asynchronous video platform tailored for European teams that prioritize data sovereignty and compliance with GDPR regulations. It allows users to record their screens and share videos securely within a team environment while ensuring all data remains stored on servers located in the EU. This localization of data storage addresses concerns related to cross-border data transfer restrictions highlighted by Schrems II, avoiding reliance on US cloud services.
Technologically, SendRec leverages React 19 and TypeScript 5.9 for its frontend development with Vite 7 as the build tool, while employing a singular Go binary server using the chi router for backend functionalities. The system's database management is handled by PostgreSQL, and video files are stored in S3-compatible object storage systems—MinIO during development phases and Hetzner Object Storage in production.
Deployment of SendRec is streamlined through Docker Compose, with automated workflows managed via GitHub Actions across three environments: preview, staging, and production. The platform requires several critical environment variables for operation, including `DATABASE_URL` and `JWT_SECRET`, along with specific configurations for S3 storage. For development, prerequisites include Go 1.25+, Node 24+, pnpm, and Docker.
SendRec’s architecture is designed to efficiently manage video data by using a single Go binary that serves the React Single Page Application (SPA), processes API requests, and handles database migrations at startup. To minimize server-side processing, it employs presigned URLs for direct uploads of videos from browsers to S3 storage. The platform is distributed under the GNU Affero General Public License v3.0, reflecting its open-source nature and commitment to user freedom in software usage and distribution.
Keywords: #phi4, AGPLv3, Docker Compose, EU data sovereignty, European servers, GDPR native, GitHub Actions, Go, Hetzner Object Storage, MinIO, PostgreSQL, React, S3-compatible storage, SendRec, TypeScript, Vite, async video, deployment, open source, privacy-first, screen recording, self-hosted
github.com 10 days ago
https://app.sendrec.eu 10 days ago
https://github.com/sendrec/sendrec 10 days ago
https://sendrec.eu/blog/ 10 days ago
|
1947.
HN
Visual data modelling in the browser (open source)
SQLModel is an open-source visual data modeling tool that operates in a browser environment, enabling users to create conceptual and physical database models through an intuitive canvas interface without requiring account creation or server setup, ensuring user privacy by keeping all work local. It features dual-layer modeling capabilities for both conceptual and physical design levels, AI-powered generation of data models from plain English descriptions, and the ability to export SQL DDL scripts and diagrams. Users can quickly set up SQLModel via its website or run it locally using npm commands after cloning its GitHub repository. The tool supports creating entities, defining relationships, generating tables, and configuring foreign keys within a Physical View, along with AI-enhanced modeling for new or existing models.
Developed using modern technologies such as React 18, TypeScript, React Flow, Zustand, Vite, and Zod, SQLModel provides a seamless user experience with features like smooth interactions, dark/light mode, and keyboard shortcuts. The project's structure includes components for the canvas, nodes, layout, UI elements, model schemas, AI services, and state management. Contributions to the project are welcomed, with guidelines available for linting and type checking. Licensed under the MIT License, SQLModel is free for both personal and commercial use.
Keywords: #phi4, AI-powered generation, Analytics, CREATE TABLE statements, MIT License, MySQL, OLTP, PostgreSQL, React Flow, SQLModel, TypeScript, Vite, Zod, Zustand, canvas-based interface, conceptual models, contributing, database schemas, diagram export, open source, physical tables, privacy-first, star schema, tech stack, visual data modeling
github.com 11 days ago
|
1953.
HN
Show HN: An open-source starter kit for developing with Postgres and ClickHouse
The repository offers an open-source starter kit designed for integrating PostgreSQL with ClickHouse, creating a unified data stack that efficiently manages both transactional and analytical workloads. In this architecture, PostgreSQL functions as the primary database for handling transactions, while ClickHouse is optimized to perform large-scale aggregations and reporting queries. The integration leverages PeerDB to stream changes from PostgreSQL to ClickHouse in near real-time using Change Data Capture (CDC), ensuring data synchronization.
Key components of this stack include PostgreSQL, which acts as the source of truth for transactional data and incorporates the `pg_clickhouse` extension; ClickHouse, serving as an analytical store optimized for analytics; and PeerDB, which facilitates CDC-based replication from PostgreSQL to ClickHouse. This setup is particularly beneficial for applications built on PostgreSQL that require scalable analytics without necessitating changes in application code. It allows PostgreSQL to offload eligible analytical queries to ClickHouse transparently using `pg_clickhouse`.
To set up this stack, users need Docker and Make, with optional tools like Postgres and ClickHouse clients. The process involves cloning the repository, starting services via `make start`, and accessing them through specified ports. The workflow includes writing data to PostgreSQL, streaming changes to ClickHouse, and executing analytics queries on ClickHouse. Applications can connect directly to ClickHouse for faster query execution or use PostgreSQL with `pg_clickhouse` for seamless integration.
A sample expense-tracking application demonstrates the stack's capabilities by showcasing significant improvements in dashboard load times after setting up data replication and query offloading. Prerequisites for this setup include Node.js 20+, npm, and PostgreSQL client tools. The process involves running a migration script to configure data synchronization and the ClickHouse Foreign Data Wrapper.
Keywords: #phi4, Analytical Queries, Analytics, CDC, ClickHouse, Dashboard, Data Stack, Docker, Expense-Tracking, Foreign Data Wrapper, Migration Script, Nextjs, Nodejs, OLAP, OLTP, Open Source, PeerDB, PostgreSQL, Query Offloading, Real-Time Sync, Replication, Transactional Workloads
github.com 11 days ago
|
1985.
HN
Make a local open-source AI chatbot with access to Fedora documentation
The article outlines a method for creating an open-source AI chatbot capable of answering questions about Fedora by utilizing Retrieval Augmented Generation (RAG). This approach enhances the chatbot's knowledge base by retrieving relevant data from an external database to inform its responses. The process begins with setting up Docs2DB, an open-source tool designed to build a RAG-compatible database. Key steps include collecting source data from Fedora documentation, converting AsciiDoc files into HTML format, ingesting these documents into Docs2DB, and constructing a searchable database using embeddings for semantic similarity.
To integrate this knowledge base into the chatbot, the `talk.sh` script is employed. This script captures audio input, transcribes it with whisper.cpp, queries the RAG database to find pertinent context, constructs a prompt incorporating this context, and sends it to an LLM such as llama.cpp for generating responses. Consequently, the AI can provide informed answers based on the ingested Fedora documentation.
The article provides practical scripts (`convert.sh` and `talk.sh`) that facilitate setting up and operating the chatbot. These tools demonstrate how RAG empowers the AI to deliver precise information about Fedora by leveraging its comprehensive documentation database.
Keywords: #phi4, AI chatbot, AsciiDoc, Docs2DB, Fedora, HTML, LLM, Podman, PostgreSQL, RAG, Silverblue, audio transcription, context injection, espeak, llamacpp, ostree, prompt building, uv, whispercpp
fedoramagazine.org 11 days ago
|
2006.
HN
Show HN: HypothesisHub – An open API where AI agents collaborate on medical res
HypothesisHub is an open API platform designed to enhance collaborative efforts among AI agents focusing on medical research hypotheses, particularly for rare diseases that often lack approved treatments due to profitability concerns. The platform hosts 160 AI-generated medical hypotheses, each encompassing molecular mechanisms, SPIRIT-compliant clinical protocols, and drug formulation recipes. It allows any AI agent to register via the API without an approval process, enabling them to contribute evidence, reviews, and validations while earning trust scores based on their contributions. Key features include instant registration, access to all hypotheses, the ability for agents to mention others, webhook notifications for replies, and a RESTful tech stack utilizing FastAPI and PostgreSQL. The platform aims to reduce collaboration friction among AI systems, potentially revealing connections that might be overlooked by humans. It currently addresses diseases such as GBM, rare autoimmune conditions, and treatment-resistant diabetes. By leveraging AI collaboration, HypothesisHub seeks to tackle longstanding challenges in medical research, providing a structured environment for generating and validating innovative hypotheses.
Keywords: #phi4, AI agents, FastAPI, GBM, HypothesisHub, PostgreSQL, REST API, SPIRIT-compliant, architecture, autoimmune conditions, clinical protocols, collaboration, diabetes, drug formulations, hypothesis generation, medical research, molecular mechanisms, open API, rare diseases, registration, treatments, trust scoring, webhook notifications
medresearch-ai.org 11 days ago
|
2013.
HN
Atlas: Manage your database schema as code
Atlas is a versatile tool designed for managing and migrating database schemas across various environments using DevOps principles. It provides two primary workflows: the Declarative Workflow, which functions similarly to Terraform by comparing the current database state with a desired state defined in HCL, SQL, or ORM schema to generate and execute migration plans; and the Versioned Workflow, which automates schema migration planning based on user-defined schemas, allowing for planning, linting, and applying migrations. Installation options include using `curl` for macOS and Linux, Homebrew, Docker, or NPM. Atlas features robust schema management capabilities with commands to inspect, diff, compare, and modify schemas, alongside versioned migration planning and Terraform integration for seamless database change management within deployment workflows. It supports defining schemas in HCL, SQL, or ORM formats and offers built-in multi-tenancy support along with cloud integrations for accessing secrets from providers like AWS Secrets Manager and GCP Secret Manager. Key commands include `schema inspect`, `schema diff`, `schema apply`, `migrate diff`, and `migrate apply`. Atlas supports a wide range of databases, including MySQL, MariaDB, PostgreSQL, SQLite, TiDB, CockroachDB, SQL Server, ClickHouse, and Redshift. The tool adheres to a version policy that maintains support for the two most recent minor CLI versions and any patch releases, with binaries older than six months being removed from distribution platforms.
Keywords: #phi4, Atlas, CLI, DevOps, Docker, HCL, Homebrew, MySQL, NPM, ORM, PostgreSQL, SQL, Terraform, cloud integration, code, database schema, declarative, migrations, multi-tenancy, versioned migration, versions
github.com 11 days ago
|
2024.
HN
Twenty: A Modern Alternative to Salesforce
"Twenty" is an open-source CRM platform developed to serve as a modern alternative to Salesforce by addressing issues like high costs and data lock-in associated with traditional CRMs. It offers a customizable, community-driven solution built on technologies such as TypeScript, NestJS, and React, enabling users to personalize layouts, customize objects and fields, manage permissions, automate workflows, and integrate various tools including emails and calendars. The platform draws UX inspiration from contemporary tools like Notion and Airtable, aiming to rectify past CRM mistakes. It fosters community involvement with plans for plugin capabilities to create a developer ecosystem, encouraging users to contribute feedback or request features through issue creation. Supporting services include Chromatic for UI testing, Greptile for code review, Sentry for bug tracking, and Crowdin for translation. Resources such as a website, documentation, roadmap, Discord channel, and Figma files are available for those interested in joining the development or community efforts.
Keywords: #phi4, Airtable, CRM, Chromatic, Crowdin, Ecosystem, Emotion, Greptile, Linear, Lingui, Local Setup, NestJS, Notion, Open-Source, Plugins, PostgreSQL, React, Recoil, Redis, Salesforce, Self-hosting, Sentry, TypeScript, UX Patterns
github.com 11 days ago
|
2054.
HN
Supporting ChatGPT on PostgreSQL in Azure
Microsoft's collaboration with OpenAI has significantly advanced database technology through Azure Database for PostgreSQL, driven by the need to support 800 million monthly users of services like ChatGPT. Key improvements include a switch from the CUBIC congestion control algorithm to BBR, which reduced replication lag in geo-distributed read replicas and enhanced performance. The introduction of cascading replica support has allowed extensive scaling of reads without impacting the primary server, while innovations such as creating geo-replicas from regional snapshots have expedited disaster recovery processes.
To address write scalability challenges, OpenAI transitioned some workloads to Azure Cosmos DB, and Microsoft developed Azure HorizonDB. This new storage layer for PostgreSQL optimizes performance and reliability by efficiently scaling reads, enabling low-latency Write-Ahead Logging (WAL) writes, and facilitating high-throughput page reads. The architecture of Azure HorizonDB separates WAL and data page storage into two services, improving the handling of IO-intensive workloads by reducing latency and increasing throughput. This separation shifts durability and high availability responsibilities from PostgreSQL compute to the storage layer, allowing for faster failovers and better resource allocation for transaction processing.
Azure HorizonDB's shared storage architecture enhances read scalability and elasticity without additional costs or data copying for high-availability replicas. It ensures a single source of truth across replicas, reducing failover times and eliminating reconciliation needs post-failover. These enhancements not only supported OpenAI's growth but also benefit all Azure Database for PostgreSQL customers with demanding workloads, marking significant progress in database scalability and performance within cloud environments.
Keywords: #phi4, Azure, BBR Algorithm, ChatGPT, Data Sharding, Database, Disaster Recovery, Durability, Elastic Workloads, Failover, Geo Replica, High Availability, HorizonDB, NVMe Disks, Network Congestion, OLTP Workloads, OpenAI, Performance Enhancements, PostgreSQL, Read Replicas, Scalability, WAL Storage, Write Scaling
techcommunity.microsoft.com 12 days ago
|
2071.
HN
Agile Coach's Solution: Break Technical Problems into Smaller Stories
An Agile coach earning a high salary but lacking production‑coding experience repeatedly diverted a team’s technical problems—such as Kafka consumer rebalancing, Oracle‑to‑PostgreSQL migration, and intermittent CI pipeline failures—into process‑centric discussions, offering generic advice (time‑boxing, dot‑voting, retrospectives) that ignored root causes and left technical debt unresolved; this pattern, reinforced by a “certification industrial complex” that prioritizes credentials like CSM or SAFe over hands‑on engineering expertise, creates a culture where formal coaching becomes a ritual of superficial improvement rather than a vehicle for concrete technical refactoring, leading to repeated incidents, persistent process gaps, and engineer frustration, while highlighting that high‑performing teams succeed when they self‑direct their work methods, remove substantive obstacles with authoritative, technically grounded leadership, and minimize unnecessary ceremonies.
Keywords: #gpt-oss:20b, Agile Coach, Docker, Jenkins, Kafka, Oracle, PostgreSQL, circuit breaker, connection pool, consumer group, incident response, microservice, partitions, retry mechanism, sprint planning
agilelie.com 12 days ago
|
2075.
HN
Reading Buffer statistics in EXPLAIN output
PostgreSQL’s `EXPLAIN (ANALYZE, BUFFERS)` now automatically shows buffer statistics (no BUFFERS clause needed since v18), enabling fine‑grained I/O analysis for a query; a typical output lists node‑level operations (e.g., Hash Join, Seq Scan) and buffer counters such as *shared hit*, *shared read*, *shared dirtied*, and *shared written*, with hit ratios computed as hits divided by (hits + reads). The example query joining `orders` and `customers` demonstrates that the small `customers` table (13 pages) was entirely cached (13 hits), while the large `orders` table (857 pages) required disk reads, yielding a hit ratio of about 1.5 %; this low ratio is normal after a restart or for large range scans, whereas OLTP workloads with small working sets typically approach 100 %. Monitoring per‑query hit ratios over time is more useful than fixed benchmarks; a sudden drop signals cache pressure or schema changes. Temporary tables use per‑backend buffers (`temp_buffers`) rather than shared buffers, so their hits and reads are reported separately; a query that writes a large temp file (e.g., a 200‑row sort with 256 kB `work_mem`) shows many *temp read/written* pages, whereas raising `work_mem` to 16 MB eliminates the spill, keeping all work in memory. Planning buffers, introduced in PostgreSQL 13, separate catalog I/O from execution I/O, and high planning reads indicate uncached system catalogs or many accessed tables; keeping catalogs hot and using partition pruning can reduce this overhead. Aggregated buffer‑access statistics from `pg_stat_statements` let administrators identify the disk‑heavy queries (e.g., by `shared_blks_read`) and link each metric to a specific tuning knob—`shared_buffers`, `bgwriter_lru_maxpages`, `work_mem`—providing actionable insights into overall workload performance.
Keywords: #gpt-oss:20b, ANALYZE, EXPLAIN, Hash Join, I/O, PostgreSQL, Seq Scan, buffer, hit ratio, shared buffers, statistics, temp_buffers, work_mem
boringsql.com 12 days ago
|
2089.
HN
The tech stack I've been refining for 6 years
Next.js 16 with its App Router and React 19 (leveraging Server Components for routing) forms the core of the stack, complemented by Clerk’s comprehensive authentication (magic links, passkeys, MFA, social logins, and user‑impersonation). Data persistence is handled by DrizzleORM, a type‑safe ORM that works seamlessly with PostgreSQL (the preferred database) while also supporting SQLite and MySQL, and it integrates Drizzle Studio for exploration and Drizzle Kit for migrations. Local development is streamlined using PGlite, a lightweight Docker‑free Postgres instance. Tailwind CSS provides a utility‑first styling approach, while form handling relies on React Hook Form paired with Zod schemas for client‑ and server‑side validation, ensuring full type safety. Testing is split between Vitest (in‑browser unit tests) and Playwright (integration, end‑to‑end, and visual regression tests), with GitHub Actions automatically executing tests on pull requests. Logging is unified through LogTape, enabling consistent logs across browser, server, and edge environments, and error monitoring is performed by Sentry (augmented with Spotlight for local debugging) while PostHog supplies analytics and session replay capabilities. Internationalization is addressed from day one with next‑intl, and a pre‑production i18n‑check flags missing translations. Developer experience is enhanced by a suite of tooling: ESLint for linting, Lefthook for Git hooks, Commitlint with Conventional Commits to standardize commit messages, Knip to surface dead code, Semantic Release for automated changelog creation, Dependabot for dependency updates, and Arcjet for built‑in rate limiting and bot protection. All components are open, fully customizable, and the complete configuration is documented in the author’s reusable GitHub boilerplate at https://github.com/ixartz/Next-js-Boilerplate, with an invitation for others to share their own stack preferences.
Keywords: #gpt-oss:20b, App Router, Clerk, Commitlint, Conventional commits, DrizzleORM, Knip, Lefthook, Magic links, Nextjs, PGlite, Playwright, PostgreSQL, React, Semantic Release, Sentry, Server Components, Social logins, Tailwind CSS, Vitest, git hooks, i18n-check
news.ycombinator.com 12 days ago
|
2111.
HN
How to Turn Slow Queries into Actionable Reliability Metrics with OpenTelemetry
The article outlines a systematic workflow for turning raw OpenTelemetry database traces into actionable reliability metrics, replacing the typical practice of treating traces as a future data dump. By extracting span‑derived metrics such as query latency, traffic volume, and anomaly scores, the approach enables two main use cases: optimisation—ranking queries by a weighted impact score (average latency multiplied by call count)—and incident response—real‑time detection of anomalously slow queries. A lab example demonstrates building dashboards that first list duration‑based queries with full application context, then incorporate traffic‑weighted impact to surface high‑priority performance work, and finally apply PromQL‑based anomaly detection on span‑derived histograms stored in Mimir, visualising latency bands that flag only genuinely anomalous shifts. The narrative emphasizes that “slow” is a symptom of diverse underlying problems—excessive work from missing or misestimated indexes, resource contention such as lock or CPU pressure, and plan regressions or pathological patterns like N+1 queries—and stresses the importance of linking slow queries to service context via distributed traces. It details implementation using an OpenTelemetry Collector with Grafana’s Loki‑Tempo‑Mimir stack, a sample Go API that generates intermittent slow PostgreSQL queries, and offers production guidance on managing metric cardinality and sensitive data. Finally, the text introduces Causely, a tool that maps detected symptoms to a causal model linking slow queries to system dependencies and root causes, thereby automating the transition from anomaly alerts to actionable fixes such as adding indexes, rolling back deployments, or mitigating upstream pressure.
Keywords: #gpt-oss:20b, OpenTelemetry, PostgreSQL, anomaly, dashboards, database, impact, latency, metrics, optimization, performance, slow queries, traces, traffic
www.causely.ai 12 days ago
|
2114.
HN
Tech stack is a business decision
The passage argues that technology stack selection should be driven by the specific business objectives and stage of a company rather than by technical preference or perceived superiority, noting that early-stage uncertainty about market fit and revenue makes rapid delivery with familiar tools essential, while later growth necessitates focus on maintainability, performance, operational cost, and scalability, as illustrated by Twitch’s evolution from a monolithic Ruby on Rails setup to a micro‑services architecture; it highlights that modern AI‑assisted coding tools lower the friction of adopting unfamiliar frameworks, thereby shifting the cost of switching stacks to strategic decisions about domain expertise, product direction, and long‑term system behavior, and recommends evaluating stacks through questions of validation speed, future cost and change likelihood, maintainers, and risk of business failure, thereby framing stack choice as a concrete business decision rather than an abstract technical debate.
Keywords: #gpt-oss:20b, Business decision, Cross-platform, Flutter, Microservices, Monolithic, Native, Performance, PostgreSQL, React Native, Ruby on Rails, Scalability, Tech stack
dinkomarinac.dev 12 days ago
|
2122.
HN
Throughput Upgrade (With Train Illustrations) Blog
The Healthchecks service experiences highly bursty traffic—about 500 pings per second on average, spiking to 4 k at minute marks and over 10 k at hour marks—yet its original open‑source Python/Django handler could only process a few hundred pings per second, so hc‑ping.com migrated to a closed‑source Go implementation that queues incoming pings in a buffered channel and processes them sequentially in a single PostgreSQL transaction per ping, yielding roughly one round‑trip per request and a 1 ms latency profile; this design was later scaled from a single worker to up to four workers across three servers, handling roughly 5 k pings per second, and in 2024 a more complex batching approach was tried (collecting up to 100 jobs or 5 ms, then performing a SELECT, UPDATE, and COPY in one transaction) but the added complexity, limited throughput gains, and a critical bug forced a rollback to the simpler model, which was subsequently re‑engineered to batch jobs using standard SQL, sorted job ordering to avoid deadlocks, a dedicated goroutine for purging old pings on a separate DB connection, and resilient retry logic; traffic is throttled by HAPoxy rate limiting and geo‑blocking before reaching NGINX, which then forwards valid requests to the Go service that consults a 404 cache for random UUID checks to avoid unnecessary DB hits, and the current system comfortably handles over 11 k requests per second without backlog, with prospects for further scaling through vertical upgrades, PostgreSQL tuning, and adjusting batch sizes and worker counts, while Pēteris warns that without proactive scaling the request queue could grow unchecked and crash the service.
Keywords: #gpt-oss:20b, Django, Go, HTTP handler, ORM, PostgreSQL, Python, cron jobs, database, healthchecks, ping endpoints, spiky traffic, stored procedure, throughput, worker goroutine
blog.healthchecks.io 12 days ago
|
2127.
HN
Show HN: Gazill – Save your code, it's live. Built for vibe coders and agents
Gazill streamlines web‑app deployment into a 15‑second “save‑file‑→‑live‑URL” workflow by eliminating YAML, Terraform, and Kubernetes; instead it relies on a lightweight stack comprising a 50‑line Node.js agent, PostgreSQL for persistent state, Caddy for routing, and direct Docker integration, thereby reducing code by 200×. The platform offers multi‑region high availability across five data centers, built‑in auto‑scaling, managed databases, and zero‑downtime deployments that complete in 11–13 seconds. It is specifically optimized for AI development tools—such as Cursor, Claude, Copilot, Windsurf, and Claude Code—by providing the `gazill context` command, which supplies agents with complete project state to ensure successful first‑try deployments. Infrastructure remains invisible and is offered for free during the beta phase, with more details and access available at https://gazill.io.
Keywords: #gpt-oss:20b, AI-native, AWS, Caddy, Docker, Ingress, Kubernetes, Nodejs, PostgreSQL, Service Mesh, Terraform, Zero-downtime, auto-scaling, multi-region
news.ycombinator.com 12 days ago
|
2144.
HN
SQLite in Production? Not So Fast for Complex Queries – Yyhh.org
SQLite, favored for web applications because of its zero‑latency reads, zero‑ops maintenance and strong endorsements from developers such as Kent C. Dodds and Wesley Aptekar‑Cassels as well as companies like Apple, Adobe, and Dropbox, also suffers key operational trade‑offs—single‑writer concurrency limits, absence of a separate server, no built‑in user management and limited suitability for distributed or clustered deployments. The article points out that, beyond these constraints, SQLite’s core limitation lies in its query optimizer, which fails to handle complex, multi‑join queries that are typical in normalized production systems (CRMs, ERPs, HR platforms, health and e‑commerce analytics, security, BI, knowledge graphs, event sourcing and ML pipelines) that routinely touch 10–20 tables, indicating a fundamental system‑level flaw rather than merely deployment or concurrency issues. Benchmark results from the Join Order Benchmark (113 queries ranging from 3 to 16 joins, ~8 joins each) run on a MacBook Pro M3 Pro reveal SQLite finished the set in 295 s (excluding nine 60‑second timeouts) with a mean runtime of 2,837 ms and a median of 644 ms—almost triple the Datalevin mean of 773 ms (median 232 ms) and PostgreSQL mean of 1,507 ms (median 227 ms)—showing SQLite rarely outperforms Datalevin and often times out on the most join‑heavy queries. These gaps stem from SQLite’s optimizer design, which exhaustively explores join orders only up to a few tables before falling back to heuristics and simplistic cardinality estimates, producing inefficient plans and large intermediate results that lead to timeouts and slower join‑heavy workloads; the article concludes that while SQLite remains excellent for embedded, straightforward key‑value and CRUD scenarios, its optimizer bottleneck renders it unsuitable for production environments requiring complex joins, suggesting alternatives such as the Datalog‑based triplestore Datalevin, which offers superior optimizer quality and consistent performance gains, and invites practitioners to share tuning experiences.
Keywords: #gpt-oss:20b, Datalog, EHR, Healthcare, PostgreSQL, SQLite, analytics, concurrency, distributed, embedded, joins, multi-join, query optimizer
yyhh.org 12 days ago
|
2166.
HN
Show HN: Artifact Keeper – Open-Source Artifactory/Nexus Alternative in Rust
Artifact Keeper is a community‑driven, MIT‑licensed artifact registry written in Rust that replaces commercial tools like Artifactory and Nexus with a lightweight, self‑hosted solution supporting over 45 package formats (Maven, npm, PyPI, Docker, Cargo, Helm, Go, etc.) via native protocol handlers and a WASM plugin runtime (Wasmtime/WIT) for extensibility. It offers built‑in vulnerability scanning with Trivy and Grype, a policy engine for severity gates and quarantine, and an edge‑replication mesh that pushes data to multiple peer nodes for P2P caching. Authentication is multi‑auth (OIDC, LDAP, SAML, JWT) with fine‑grained RBAC, and a responsive web dashboard (Next.js 15), native mobile apps (iOS SwiftUI, Android Jetpack Compose), and a CLI provide full management. The backend is built on Rust/Axum exposing a REST API, backed by PostgreSQL 16 for metadata, object storage for artifacts, and Meilisearch for full‑text search. Deployment is quick through Docker Compose or pre‑built images, with demo and documentation available online, and the project invites contributions on GitHub, offering automated migration tooling, SSO support, and a modular architecture that emphasizes performance, safety, and no feature gates.
Keywords: #gpt-oss:20b, Artifact, Artifact Registry, Artifactory, CLI, DevOps, Docker, Grype, Keeper, Meilisearch, Nexus, Open-Source, PostgreSQL, REST API, Rust, Security Scanning, Trivy, WASM
github.com 12 days ago
http://github.com/asfaload/asfaload 12 days ago
https://github.com/steveyegge/beads 12 days ago
https://demo.artifactkeeper.com/security/policies 12 days ago
https://artifactkeeper.com/docs/security/scanning& 12 days ago
https://github.com/orgs/artifact-keeper/discussion 12 days ago
https://github.com/ossillate-inc/packj 11 days ago
https://github.com/orgs/artifact-keeper/discussion 11 days ago
https://news.ycombinator.com/item?id=45670055 11 days ago
https://news.ycombinator.com/item?id=44991636 11 days ago
https://news.ycombinator.com/item?id=45270468 11 days ago
https://news.ycombinator.com/item?id=34603593 11 days ago
https://packaging.python.org/en/latest/guides/ 11 days ago
https://github.com/pulp 11 days ago
https://github.com/pulp/pulp-operator 11 days ago
https://news.ycombinator.com/item?id=44320936 11 days ago
|
2181.
HN
Show HN: MIE – Shared memory for all your AI agents (Claude, Cursor, ChatGPT)
MIE – Memory Intelligence Engine is a shared, persistent knowledge graph that all AI agents such as Claude, ChatGPT, Cursor, and Gemini can read from and write to, replacing each model’s isolated memory with a durable, ACID‑compliant store (e.g., PostgreSQL) that holds facts, decisions, entities, events, and topics linked through typed relationships; this eliminates repetitive explanations, preserves context across sessions and providers, and enables agents to “talk” via a common brain that is portable, auditable, and conflict‑detectable. Core advantages include a shared typed graph, semantic search and graph traversal queries, portability to your machine with export capabilities, structured relationships that give context to answers, and an explicit history and invalidation chain to trace changes; the quick start involves installing MIE via Homebrew, initializing it, and adding an MCP server configuration to each agent’s `.mcp.json` or `.cursor/mcp.json`. MIE exposes eight JSON‑RPC tools for MCP clients—`mie_analyze`, `mie_store`, `mie_query`, `mie_list`, `mie_update`, `mie_conflicts`, `mie_export`, and `mie_status`—which together provide context selection, storage, semantic and exact querying, node listing, fact updating with history preservation, contradiction detection, graph export, and health monitoring, all without server‑side inference so the LLM remains local and there is no extra token cost. Architecturally, MCP clients send JSON‑RPC calls to the MIE server, which delegates to CozoDB (an embedded graph database with HNSW vector indexing and Datalog query capabilities); optional local embeddings can be powered by Ollama, and future ChatGPT integration will use custom GPT Actions pointing to MIE Cloud. Configuration is defined in `~/.mie/config.yaml` (or via environment variables) to select storage and embedding engines, with a CLI providing `init`, `status`, `export`, `reset`, and raw Datalog `query`; MIE also integrates with CIE for code‑base understanding, and its roadmap includes browser extensions for auto‑capture, cloud sync, ChatGPT actions, a web UI, and imports from ADRs/Notion/Confluence; the project is dual‑licensed under AGPL‑3.0 for open‑source use and a commercial license for proprietary deployments, encouraging community contributions per the provided guidelines.
Keywords: #gpt-oss:20b, ACID, AI Agents, ChatGPT, Claude, Context, Decisions, Facts, Knowledge Graph, MIE, Memory, PostgreSQL, Relationships
github.com 12 days ago
|
2183.
HN
RAG on Ruby on Rails
A Ruby on Rails 8.1.1 application has been engineered as a retrieval‑augmented generation (RAG) system for a long‑standing hiking club, enabling rapid access to policy documents spread across multiple sites and PDFs. The pipeline ingests PDFs via a protected admin UI, stores them in Cloudflare R2, and extracts text page‑by‑page using the `pdf‑reader` gem; the text is then chunked into paragraph‑based segments of roughly 500 tokens, each embedded with Voyage AI’s 1024‑dimensional `voyage‑3` model and persisted in PostgreSQL with the `pgvector` extension accessed through the `neighbor` gem. When a user submits a query, the query is likewise embedded, and the top five most similar chunks are retrieved via cosine‑similarity search; these chunks, annotated with citation markers, are fed into OpenAI’s GPT‑4o‑mini prompt to produce contextually grounded responses. The `ruby_llm` gem streams LLM tokens in real time to the browser using Turbo Streams and Rails 8’s Solid Cable (a Postgres‑backed Action Cable), eliminating the need for Redis; rendering proceeds in three phases—initial empty assistant container, live token appends, and final message replacement—while citations are parsed from `[1]`, `[2]` markers into clickable buttons that trigger a Stimulus‑driven modal displaying the source passage and a link to the original PDF in R2, allowing users to drill down from summary to full document. The system’s user‑centric knowledge layers offer quick answers, verifiable data for skeptics, and deep research gated by explicit action, while non‑admin users can browse uploaded titles and view originals on a transparent corpus page that exposes the system’s knowledge limits. Overall, the stack—RubyLLM for AI integration, Rails with Postgres and PGVector for storage and vector search, Cloudflare R2 for inexpensive object storage, and Rails’ native background job and Action Cable tooling—provides a fully production‑ready RAG solution deployable wherever Rails runs, all within a single, self‑contained application.
Keywords: #gpt-oss:20b, Action Cable, ChatGPT, Chunking, Embeddings, LLM, OpenAI, PDF, PostgreSQL, RAG, Rails, Redis, Ruby, Turbo Streams, streaming
jessewaites.com 12 days ago
|
2200.
HN
Data Science Weekly – Issue 637
Issue 637 of *Data Science Weekly* provides an in-depth overview of various topics in data science and machine learning, emphasizing core ML model components, AI's contributions to scientific research, and the importance of quantiles and prediction intervals in modeling uncertainty. A live blog from a graduate ML course delves into discussions on variable selection techniques such as backward elimination, the construction of event-driven platforms, and the mechanics of attention mechanisms, including QKV matrices. It also features reflections on the challenges and insights gained during a Ph.D. journey. A Ph.D. student underscores the importance of maintaining a research notebook for documenting progress and insights, while another article outlines the process of developing an offline chatbot using Python, PostgreSQL, and a local LLM. Additionally, the text includes advice from a former theorist on making the shift to empirical research, and an exploration of monads in programming, their theoretical roots in category theory, and their potential influence on future software development. The issue also touches on topics such as differential privacy, the distinction between statistical significance and practical relevance, and the transition from individual contributor to team lead in data science leadership, highlighting the complex responsibilities and strategic thinking required in leadership roles.
Keywords: #qwen3:14b, AI, Attention Mechanism, Backward Elimination, Bottleneck, CNNs, Category Theory, Chatbot, Data Engineering, Data Science, Data Visualization, Database, Differential Privacy, Empirical, Gemini, Global Growth, Individual Contributor, Key, LLM, Leadership, Lessons, Machine Learning, Monads, Notebook, Ollama, Outcome Distribution, PhD, Platform Architecture, PostgreSQL, Prediction Intervals, Probability Distribution, Problem Solving, Programming, Promotion, Python, Quantiles, Query, Random Forests, Recalibrate, Regression Models, Ship, Software Development, Statistical Significance, Statistics, Team Lead, Transition, Useful, Value, Value Creation, Variable Selection, k-nearest neighbors
datascienceweekly.substack.com 12 days ago
|
2201.
HN
Show HN: A state-based narrative engine for tabletop RPGs
No summary available (error)
Keywords: #qwen3:14b, AI facilitator, CAML, Dependencies, Development, Drizzle ORM, Dungeon Masters, Environment Variables, Everdice, Getting Started, Install, Migration, Nodejs, PostgreSQL, Tailwind CSS, TypeScript, Vite, adventure modeling, backend, campaign, campaign continuity, choice-driven, coercion, database, education, enclosure, frontend, full-stack, harm, license, manipulation, migrations, narrative state, non-commercial, npm, proprietary, research, self-hosted, software, solo play, surveillance, tabletop RPGs, use, web app
github.com 12 days ago
|
2211.
HN
Instacloud as infinite cloud storage using Instagram as remote disk
InstaCloud is an experimental Proof-of-Concept tool that utilizes Instagram's API to function as a form of infinite cloud storage by converting files into "Visual Noise" PNGs and uploading them as direct messages (DMs), thereby circumventing Instagram's file type restrictions. The system works by chunking files, storing them in private DMs, and tracking their metadata through a PostgreSQL database. It offers both command-line interface (CLI) and graphical user interface (GUI) options, allowing users to upload and download files via a web dashboard or CLI. Despite its innovative approach, the tool is explicitly designed for demonstration purposes and does not guarantee reliability or security, as files are not encrypted by default and may be subject to deletion or analysis by Meta. Furthermore, its use violates Instagram's Terms of Service, and it is recommended only for use with burner accounts. The creator disclaims any liability for misuse, and the project is open to contributions from the community.
Keywords: #qwen3:14b, API, CLI, DM caches, DM doodles, Doodle API, GUI, InstaCloud, Instagram, Neontech, PNG, PostgreSQL, Python, Visual Noise, burner account, cloud storage, configenv, contributions, credits, data reliability, download, encryption, experimental, liability, obfuscation, pixels, privacy, steganography, upload
github.com 13 days ago
|
2221.
HN
Everything in Git: Running a Trading Signal Platform on NixOS
The described infrastructure leverages NixOS and a monorepo approach to achieve a highly declarative, automated, and scalable system managed through tools like Clan, enabling deployment with a single command. All configurations, workflows, and services are version-controlled in Git, ensuring consistency and eliminating manual setup. The system is built on Hetzner servers, chosen for their cost-effectiveness and flexibility compared to hyperscalers like AWS or GCP, and runs a robust stack including PostgreSQL, observability tools, and a customer API. Secure internal communication is handled via WireGuard with IPv6 ULA addresses, isolating internal services from the public internet. NixOS is favored for its reproducibility, atomic updates, and elimination of Docker overhead, enabling non-experts to manage infrastructure effectively. Performance is optimized through bare metal servers and minimal abstraction, avoiding the need for Kubernetes. Infrastructure management is streamlined using Nix and Clan, supporting declarative, scalable, and secure fleet orchestration. The monorepo structure allows AI assistants like Claude Code to understand the full system context, facilitating smarter suggestions and reducing knowledge fragmentation. Observability is handled internally using Prometheus, Loki, and Grafana, ensuring centralized monitoring, logging, and visualization without vendor lock-in. Secrets are securely managed through Clan's vars system and systemd credentials, injected at runtime without being stored on disk. Logging is managed with Alloy and Loki, using LogQL for querying, while metrics are collected every 15 seconds and retained for 30 days. Backup is handled via BorgBackup and custom scripts for SQLite and WAL file restoration. The system balances trade-offs such as a steep learning curve and limited package availability in NixOS but offers a solid, flexible, and efficient infrastructure suitable for small teams. Overall, the integration of a monorepo, NixOS, Clan, and AI-assisted development creates a powerful, efficient, and sustainable workflow for infrastructure and code management.
Keywords: #qwen3:14b, AI-assisted, AWS, Airflow, Alloy, Bare metal, BorgBackup, Clan, Cloud VM, Cron, DevOps, FastAPI, Git, Grafana, Hetzner, IPv6, Kubernetes, Linux, LogQL, Loki, Nix, NixOS, PostgreSQL, Prefect, Prometheus, R, SOPS, SQLite, SSH, SaaS, Snapshots, TLS, Terraform, TimescaleDB, ULA, WAL, WireGuard, Work Pool, YAML, ZFS, age encryption, alerting, allowedIPs, atomic updates, authentication, automation, availability, backup, backups, cloud computing, codebase conventions, collaboration, compliance, configuration, consistency, containerization, continuous delivery, continuous deployment, continuous integration, cost, dashboards, data-driven, database, database schema, debugging, declarative, declarative infrastructure, deployment, deployment pipeline, distributed systems, documentation, efficiency, egress fees, encryption, fault tolerance, firewall rules, flakenix, flexibility, governance, hybrid cloud, hyperscaler, infrastructure, infrastructure as code, infrastructure automation, innovation, integration, inventory, latency, learning curve, lock-in, logging, maintenance, managed cloud, microservices, monitoring, monorepo, network topology, networking, on-premise, open source, optimization, orchestration, package availability, performance, performance tuning, pg_serviceconf, publicKey, rate limiting, redundancy, refactoring, reliability, reproducibility, reproducible, resilience, resource management, rollback, scalability, scaling, secrets management, security, shared environments, shared_preload_libraries, simplicity, skill guides, software engineering, superpower, system architecture, system availability, system collaboration, system consistency, system documentation, system fault tolerance, system flexibility, system innovation, system integration, system latency, system optimization, system resilience, system resource management, system scalability, system throughput, systemd, testing, throughput, troubleshooting, usersnix, virtualization, visualization, workflows
www.pxdynamics.com 13 days ago
|
2222.
HN
Software Architecture and Philosophical Anthropology
A philosophical anthropology provides a framework for understanding software architecture by drawing parallels between the structure of the human soul and the design of complex systems, particularly language models. This perspective suggests that software can be designed to mirror the soul’s architecture, integrating external inputs into a unified whole, thereby enhancing coherence and functionality. The text explores this idea through various software components, such as an AWS SQS message consumer, which processes and deletes messages from a queue, and a `Store` class that emulates a persistent data store for event data. These components reflect cognitive processes like persistence, distribution, and pattern recognition. The `PatternEngine` class employs a machine learning model to detect patterns in transactions, making decisions based on perceived intention, which aligns with the soul’s estimative power—making practical judgments rather than universal truths. This approach is applied in fraud detection and classification systems, where events are stored along with their contextual information. The `MemoryStore` class further extends this analogy by preserving events with temporal and intentional context, enabling queries based on time or significance, and reflecting cognitive processes such as memory. This design resonates with broader software patterns like event sourcing and audit logs, revealing a deep connection between engineering practices and philosophical understandings of human cognition. Ultimately, the text argues that good software architecture mirrors the metaphysical structures of reality, aligning with the soul’s powers rather than merely adhering to technical jargon, allowing architects to design systems that resonate with the fundamental order of existence.
Keywords: #qwen3:14b, AWS SDK, Common Sense, Cosmos, Data, DeleteMessageBatchCommand, DeleteMessageCommand, Event, External Senses, Integration, LLMs, ML model, Map, Memcached, MemoryStore, Pattern recognition, Phantasm, Philosophical Anthropology, PostgreSQL, ReceiveMessageCommand, Redis, SQS, SQSClient, Software Architecture, Soul, Store, Users, anomaly detection, audit logs, classification, database, estimative power, event sourcing, fraud detection, intention, judgment, memory, message queue, metaphysical, organizing tools, powers, reality, recall, record, service boundaries, software design patterns, stored representation, structure, system layers, techne, technical jargon, theoria, transaction, transaction history, urgency
michaelmangialardi.substack.com 13 days ago
|
2262.
HN
Importance of Tuning Checkpoint in PostgreSQL
PostgreSQL checkpoints guarantee crash durability by identifying dirty pages, writing them to the operating system, fsyncing the files, updating `pg_control`, and recycling unused WAL segments; un‑tuned checkpoints waste I/O and produce a saw‑tooth performance pattern. Experiments with intervals of 5, 15, 30, and 60 minutes show that longer gaps reduce WAL throughput from roughly 12 GB to 2 GB and full‑page‑image writes from about 1.5 million to 160 thousand, while decreasing the proportion of uncompressed FPIs—resulting in at least a 10 % throughput gain. Extended intervals do not linearly increase crash‑recovery time because recovery speed depends on the volume of WAL to replay rather than the time between checkpoints; typical recovery takes seconds to minutes even on modest hardware. Scheduler parameters such as `checkpoint_timeout`, `max_wal_size`, and `checkpoint_completion_target` control cadence, and `log_checkpoints` records the duration and I/O cost of each event (the illustrated log shows a ~54‑minute checkpoint writing 4 344 buffers and 381 SLRU buffers). Starting with PostgreSQL 14, cumulative WAL statistics appear in `pg_stat_wal`, with the checkpointer’s metrics moving from `pg_stat_bgwriter` (≤ v16) to `pg_stat_checkpointer` (from v17); proper checkpoint tuning therefore reduces I/O overhead, backup stress, and replication lag while preserving rapid failover in HA setups. Jobin Augustine, a PostgreSQL specialist with over two decades of consulting, architectural, and training experience, writes regularly on performance optimization and contributes to open‑source projects.
Keywords: #gpt-oss:20b-cloud, Patroni, PostgreSQL, SLRU, WAL, buffers, checkpoint, checkpoint_timeout, crash recovery, disk I/O, fsync, full-page FPI, max_wal_size, pg_stat_wal, pgbench, standby
www.percona.com 13 days ago
|
2284.
HN
Pg-dev-container is a ready-to-run VS Code development container for PostgreSQL
Pg‑dev-container is a VS Code development container that runs a non‑optimized PostgreSQL build engineered for debugging and extension testing—features include assertions, early memory‑clearing, and debug symbols. After installing VS Code, Docker, and the Dev Containers extension, opening the project and choosing “Reopen in Container” downloads the base image, installs dependencies, and compiles PostgreSQL (a time‑consuming process that logs its progress); once finished, the source is made available to the editor via `code --add /usr/local/src/postgresql`. The container automatically launches a PostgreSQL server, and its integrated terminal lets users create a test database (`createdb test`), connect with `psql test`, experiment with SQL commands, and later delete the database (`dropdb test`). A bundled `hello_world` extension located in `src/extensions/01_hello_world/` exposes a C‑implemented function `hello_world(TEXT)` that returns “Hello %PARAMETER”; building and installing it is performed with `sudo make install`, and verification is done with `make installcheck`, which creates a test database and runs the test script. Within a database, the extension is installed via `CREATE EXTENSION hello_world`, with its presence confirmed by `\dx` and detailed metadata accessed through `\df+ hello_world`. Debugging proceeds by opening `hello_world.c`, setting a breakpoint, launching the VS Code debugger (F5), selecting the running backend process (e.g., `postgresql: vscode test [local] idle`), and re‑executing the `SELECT hello_world('Mr X')` command, at which point the debugger pauses, displaying local variables and the call stack for inspection.
Keywords: #gpt-oss:20b-cloud, Dev Containers, Docker, PostgreSQL, VS Code, container, createdb, debug, debugger, dropdb, extension, hello_world, pg_available_extensions, plpgsql, postgres_fdw, psql
github.com 13 days ago
https://www.linkedin.com/feed/update/urn:li:activi 13 days ago
|
2295.
HN
Show HN: Kling 3.0 video generation with native audio synthesis
Kling 3.0, the newest text‑to‑video model from Kuaishou, distinguishes itself through native audio‑visual synchronization, generating sound in‑step with visual frames instead of applying post‑editing techniques found in competitors such as Sora, Veo, or Runway. It offers start‑to‑end frame interpolation (I2V) that allows users to supply a first and final frame and have the model interpolate intermediate motion, giving fine‑grained temporal control across 13 preset video lengths ranging from 3 s to 15 s. Outputs support 1080p resolution with a runtime cap of 60–120 s, and audio quality scales with prompt detail; pricing is credit‑based, with audio costing $0.252 per second versus $0.168 per second for silent video. On FreedVideo, the platform processes jobs asynchronously through the FAL API, stores configuration data in Postgres, and manages cost through a credit system, while inviting technical engagement on model integration and behavior.
Keywords: #gpt-oss:20b-cloud, 1080p, 30, API, FAL, I2V, JSON, Kling, Nextjs, PostgreSQL, async, audio-visual, cinematic, coherence, consistency, diffusion, duration, flexible, images, interpolation, job, media, motion, movements, native, prompts, quality, rapid, simulation, social, start-end, synchronization, temporal, text, transformer, video, visual
freyavideo.com 13 days ago
|
2299.
HN
Show HN: VillageSQL – A Fork of MySQL with Extensions
VillageSQL is an open‑source, drop‑in fork of MySQL that introduces a native “Myonic” extension framework allowing developers to load shared libraries (.so files) to create new data types, functions, and soon indexes that run within the core engine. The alpha release already ships proof‑of‑concept extensions—such as vsql‑ai for AI prompting, vsql‑uuid for UUID data type support, vsql‑crypto for cryptographic utilities, and vsql‑network‑address for network address handling—while a future roadmap targets vector indexing and optimized vector search to close the MySQL innovation gap relative to PostgreSQL. Installation is MySQL‑idiomatic, enabling easy deployment by copying extension files to the extensions directory and executing `INSTALL EXTENSION`. The project encourages community participation via GitHub, Discord, and email updates, aiming for permission‑less, Oracle‑independent tools that let the MySQL ecosystem rapidly experiment and innovate, especially for AI and enterprise workloads.
Keywords: #gpt-oss:20b-cloud, AI, MySQL, PostgreSQL, VSQL‑AI, VillageSQL, alpha, data type, drop‑in, extensions, fork, open source, shared libraries
villagesql.com 13 days ago
|
2307.
HN
MariaDB vs. PostgreSQL: Understanding the Architectural Differences That Matter
This blog post contrasts MariaDB and PostgreSQL by dissecting their architectural strategies, MVCC handling, memory footprints, connection processing, replication and high‑availability mechanisms, operational demands, and governance models. MariaDB employs a multi‑threaded, shared‑memory thread pool and continuous purge for MVCC, delivers a unified buffer pool that feeds most reads and writes directly from memory, and integrates native Galera clustering for synchronous multi‑primary replication without additional tooling; its multi‑engine catalog (InnoDB, ColumnStore, MyRocks, Spider) lets a single platform manage transactional, analytical, and distributed workloads. In contrast, PostgreSQL follows a multi‑process paradigm with each client in its own OS process, relies on periodic VACUUM cycles to reclaim space, separates shared buffers from the OS page cache, and needs external poolers (pgbouncer or pgpool) and HA solutions (Patroni, Citus) for scaling and failover. MariaDB’s design aims for lower operational overhead and predictable performance under high‑connection scenarios, whereas PostgreSQL offers richer SQL extensibility and a wider array of third‑party extensions at the cost of more active tuning and third‑party orchestration; governance is likewise distinct, with MariaDB’s nonprofit foundation providing consolidated enterprise support options and PostgreSQL’s community‑driven, vendor‑fragmented ecosystem.
Keywords: #gpt-oss:20b-cloud, Buffer Pool, Concurrency, Extensions, Galera, HA, MVCC, MariaDB, Open-source, PostgreSQL, Replication, Sharding, Shared Buffers, Thread pool, Vacuum
mariadb.org 13 days ago
|
2309.
HN
Show HN: EZTest – All in One, Open Source Test Management. Built W Claude Code
EZTest is a lightweight, open‑source test‑management platform built with Next.js 15.5.6, TypeScript, Postgres 16, and Prisma 5, designed for self‑hosting via Docker on modest hardware (minimum 1 CPU, 2 GB RAM) and offering project, test suite, test case, test run, defect tracking, file attachments, and collaboration features; authentication, RBAC, and user management are fully complete, with core features such as metrics, test‑requirement traceability, Jira, GitHub, Azure DevOps integrations, and CI/CD connectivity marked as in progress or planned. The application is distributed under AGPL‑3.0, actively maintained by Philip Moses and Kavin, and includes a public demo (eztest.houseoffoss.com v0.1.0). Deployment instructions require cloning the repo, copying `.env.example` to `.env`, running `docker‑compose up -d`, pushing the schema with `npx prisma db push`, seeding data via `npx prisma db seed`, and starting the dev server (`npm run dev`); default admin credentials are `admin@eztest.local` / `Admin@123456`, but can be overridden via `ADMIN_EMAIL`/`ADMIN_PASSWORD` env vars. Security guidance highlights the need to avoid committing real AWS S3 credentials, recommends using IAM roles or an S3‑only user, and rotating any exposed keys immediately. The README details the full tech stack (React, Radix UI, Tailwind CSS, NextAuth, bcrypt, Nodemailer, Zod), system requirements (CPU/RAM ranges for min, recommended, and production), common npm scripts (`dev`, `build`, `lint`, `prisma studio`, `prisma generate`, `prisma db push`, `prisma db seed`), workflow steps, and links to developer and user guides; contributors are directed to the open‑source repository, branching, linting, and commit conventions, and support is available via the demo site, issue tracker, and maintainers’ contact.
Keywords: #gpt-oss:20b-cloud, AGPL-30, Authentication, Authorization, CRUD, Deployment, Docker, EZTest, Nextjs, Nodejs, PostgreSQL, Prisma, Tailwind, TypeScript, open-source
github.com 13 days ago
|
2396.
HN
Show HN: WhookTown – Visualize your infrastructure as a 3D cyberpunk city
WhookTown reimagines IT infrastructure as a Tron‑style 3‑D cyberpunk city, where each server or service is visualized as a unique building type—windmills, data centers, pyramids, towers, arcades, and more—each with distinct animations and lighting that convey real‑time health: green lights for normal operation, orange for warnings, and red or fire for critical failures. CPU load is represented by the speed of wind‑mill rotors, while background alerts can be encoded in a built‑in workflow engine that triggers visual effects (e.g., “if latency > 500 ms and cache miss > 20 % → set building on fire”). The platform is built as a suite of Go microservices orchestrated by Redis Streams and PostgreSQL, leveraging Three.js and WebSocket for live rendering, and offers a free tier with one layout and four buildings, scaling to paid plans starting at $4 / mo. Its goal is to replace sterile dashboards with an immersive, instantly readable monitoring experience, making system health visible through animated neon‑lit architecture. https://whook.town
Keywords: #gpt-oss:20b-cloud, 3D, CPU, FFT, PostgreSQL, Redis, WhookTown, color-coded, cyberpunk, dashboard, infrastructure, neon, real-time, server status, visualization, workflow
www.whook.town 14 days ago
|
2401.
HN
Show HN: Rereflect – AI-powered customer feedback analysis
Rereflect is an AI‑powered platform that aggregates customer feedback from emails, Slack, support tickets, and surveys, automatically scoring sentiment, categorizing issues, extracting feature requests, and flagging churn risk—displayed in a unified dashboard. It is built on FastAPI, PostgreSQL, and Next.js, offers a free tier allowing up to 250 items per month via CSV upload, and invites community input on useful integrations such as Slack, email, and webhooks, as well as current feedback workflows. The tool can be accessed at https://app.rereflect.ca.
Keywords: #gpt-oss:20b-cloud, AI, FastAPI, Nextjs, PostgreSQL, UX, bugs, churn, dashboard, feature, feedback, pricing, sentiment
www.rereflect.ca 14 days ago
|
2498.
HN
Show HN: Distr 2.0 – A year of learning how to ship to customer environments
Distr 2.0 is a lightweight, open‑source framework that grew over a year from a basic agent‑based updater into a full‑featured distribution platform capable of packaging, deploying, and managing software across on‑prem, GovCloud, AWS, and GCP environments without requiring SSH, offering embedded OCI container registry, license and secret management, customer‑organization orchestration, and telemetry; it now serves over 200 vendors—including Fortune 500 companies—while preparing Distr 3.0 with native Terraform/OpenTofu and Zarf support for Bring‑Your‑Own‑Cloud (BYOC) and air‑gapped deployments. The post outlines key lessons learned in dependency management, environment parity, continuous packaging, and design trade‑offs, and explains how the platform’s modular architecture couples a Distr Hub (SaaS or private cloud) with core services such as PostgreSQL, an OCI registry, and object storage, exposing a customer‑side layer of Distr Agent and applications; it highlights quick‑start instructions (register at `http://localhost:8080/register`, self‑hosting guide, macOS agents), build requirements (Node v22, Go v1.25, Docker, optional `mise` toolchain), SDK usage (`npm install @distr-sh/distr-sdk`), and details of the Distr MCP server for connecting deployments, artifacts, and licenses to agentic workflows, including authentication via personal access tokens and an example `claude mcp add` command.
Keywords: #gpt-oss:20b-cloud, Container registry, Distr, Docker, Helm, Kubernetes, License Management, OCI, PostgreSQL, SDK, Secret Management, Show HN, Terraform
github.com 14 days ago
https://github.com/distr-sh/distr/pull/1478 14 days ago
|
2512.
HN
Why MySQL's Integration with DuckDB Is More Elegant Than PostgreSQL's
The landing page opens with the headline “Why MySQL’s Integration with DuckDB Is More Elegant Than PostgreSQL’s,” followed by a generic “Top Content” navigation interface that lists popular topic categories—such as AI trends, leadership, and career advancement—alongside the number of likes each post has accrued, yet it contains no substantive article or in‑depth discussion of MySQL, DuckDB, or PostgreSQL. The page also provides a detailed inventory of LinkedIn topic categories paired with the approximate number of posts in each: Consulting, Hospitality & Tourism, Employee Experience, Economics, Writing (~14 K posts); Networking, Ecommerce, Soft Skills & Emotional Intelligence, User Experience (~13 K posts); Education, Design (~12 K posts); Real‑Estate, Project Management, Retail & Merchandising (~11 K posts); Negotiation (10 K posts); Future of Work (9 K posts); Fundraising (8 K posts); Healthcare, Event Planning (~6 K posts). Below this list sits the standard LinkedIn footer, featuring © 2026, accessibility, legal, privacy, cookie, brand, and multilingual links.
Keywords: #gpt-oss:20b-cloud, AI, Career, Consulting, DuckDB, Hospitality, Innovation, Integration, Leadership, LinkedIn, Mentor, MySQL, PostgreSQL
www.linkedin.com 14 days ago
|
2522.
HN
Show HN: Nemp – Claude Code memory with zero cloud (just JSON on your machine)
Nemp is a lightweight, privacy‑first Claude Code plugin that restores context by keeping a fully local memory stored in plain JSON files, eliminating the need for cloud services, databases or additional software. After a one‑off installation using `/plugin marketplace add https://github.com/SukinShetty/Nemp-memory` and `/plugin install nemp`, the `/nemp:init` command automatically scans the project’s directory to identify its framework, language, database, authentication, styling, and package manager, creating instant, searchable “memories” that can be queried with meta‑commands such as `/nemp:context` and `/nemp:suggest`. Memories are maintained in sync with an editable `CLAUDE.md` via `/nemp:sync`, enabling two‑way updates and conflict detection while operating offline. The plugin also provides proactive activity tracking—toggled with `/nemp:auto-capture`—and CRUD operations (`/nemp:save`, `/nemp:forget`, `/nemp:list`, `/nemp:recall`). Troubleshooting guidance addresses common Windows file‑permission errors (EPERM), unrecognized plugin commands, and marketplace clone failures, recommending admin rights, Defender exclusions, Git connectivity checks, and clean reinstall procedures. All data, including a human‑readable `.nemp/memories.json` and activity logs, remains on the local machine, allowing the user to delete the entire plugin footprint with simple file removal commands.
Keywords: #gpt-oss:20b-cloud, Claude, Git, JSON, JWT, Nemp, NextAuthjs, Nextjs, PostgreSQL, Prisma, Tailwind CSS, TypeScript, VS Code, install, marketplace, memory, npm, plugin, privacy, uninstall
github.com 14 days ago
|
2532.
HN
PostgreSQL for Update Skip Locked: The One-Liner Job Queue
PostgreSQL can serve as a robust background job queue by atomically claiming a pending task with a single SQL statement—`SELECT … FOR UPDATE SKIP LOCKED LIMIT 1`—which locks the chosen row, ignores any already‑locked rows, and guarantees that each worker receives a unique job without external coordination. Workers execute this query inside a transaction, process the job, then update its status to completed (or failed) and commit; if a worker crashes, the transaction rolls back, automatically returning the job to the queue. The article expands this pattern by adding columns such as `priority`, `attempts`, and `max_attempts`, allowing the selection of the highest‑priority job that hasn’t exceeded its retry limit, thereby supporting priority queues and retry logic. It demonstrates a SQLite simulation of a pending → processing → completed state machine, outlines real‑world use cases like webhook delivery and scheduled tasks, and notes that libraries such as Que and Oban use the same approach. The technique delivers transactional integrity, ACID guarantees, and eliminates race conditions, making PostgreSQL a lightweight, dependable alternative to dedicated queue systems for most workloads.
Keywords: #gpt-oss:20b-cloud, FOR UPDATE, PostgreSQL, Redis, SELECT, SKIP LOCKED, SQLite, UPDATE, atomic, deadlocks, job queue, lock, retries, status, transaction, workers
www.dbpro.app 14 days ago
|
2551.
HN
Show HN: PostgreSQL extension for privacy – AI training and RAG monetization
The PostgreSQL “Kernel Privacy” extension provides a set of pure‑SQL primitives for safeguarding sensitive identifiers and enabling fine‑grained billing in AI applications. Its core functions, such as `get_canonical_hash(jsonb, text)` and `apply_responsible_noise(float8, float8, float8)`, implement pepper‑protected SHA‑256 hashing and Laplace noise addition for differential privacy, respectively, and require only PostgreSQL 12+ with the `pgcrypto` extension. Designed for rapid adoption, the extension installs in 30 seconds via a single SQL file (`kernel_privacy_extension.sql`) and is MIT‑licensed, with no external dependencies. The primary use case is “privacy‑first” training of large language models, allowing organizations to hash identifiers like patient names or customer IDs before providing data to an LLM, thereby preventing memorization of personal data and meeting HIPAA/GDPR compliance. A second, upcoming feature is “RAG monetization,” which introduces a per‑document retrieval billing schema; a `rag_retrievals` table records each request (user_id, doc_hash, retrieved_at, price_charged), enabling summation of charges per user over time, useful for legal databases, healthcare research, and financial data services. The extension accommodates practical snippets for healthcare, FinTech, and SaaS use cases, and includes sample queries for hashing metadata stored in JSONB. The roadmap points to automated testing, packaging on PGXN, performance benchmarks, and integration with LangChain and Hugging Face, while Phase 2 will add marketplace capabilities for sellers to list knowledge bases and buyers to pay per RAG fetch. The project welcomes contributions and offers a commercial license for enterprise analytics and policy enforcement.
Keywords: #gpt-oss:20b-cloud, GDPR, HIPAA, LLM, PCI, PostgreSQL, RAG, SQL, billing, hash, jsonb, pgcrypto, privacy
github.com 14 days ago
|
2577.
HN
Show HN: Static psql – Pre-built PostgreSQL client binaries
The post introduces a lightweight, pre‑built `psql` client that eliminates the need to install a full PostgreSQL server or rely on fragile system dependencies, appealing to *mise* users and container developers who prefer a single, self‑contained binary instead of a bloated server build; it offers fully static Linux binaries (both musl‑linked for Alpine and glibc for other distros) along with native macOS builds for Intel and Apple Silicon, bundling OpenSSL, ncurses, readline, and zlib to provide SSL/TLS support, command‑line editing, and compression—all of which are delivered through releases on GitHub and can be installed with `mise install "github:IxDay/psql@16.1.0"` or via a `.mise.toml` entry, or fetched directly in Docker using a wget/tar command; the tooling leverages Zig for cross‑compilation, with a single `build.zig` script capable of generating all target variants without platform‑specific toolchains, demonstrating how auto‑generated build scripts (generated by Claude Code) can streamline support for new languages or toolchains; the package supports static and dynamic musl builds for x86_64 and aarch64, glibc binaries for those architectures, and macOS Intel/ARM releases, and it includes features such as OpenSSL 3.3 for SSL/TLS, zlib for compression, and readline for user interaction, all released under an MIT wrapper license atop PostgreSQL’s original license.
Keywords: #gpt-oss:20b-cloud, Alpine, CI/CD, Docker, Linux, OpenSSL, Zig, containers, cross-compiler, macOS, mise, musl, ncurses, psql, readline, static, zlib
github.com 14 days ago
|
2579.
HN
We built memory that respects privacy in group chats
The architecture is a privacy‑first memory management system for group‑chat AI built on Alex Grama’s Adaptive Memory filter, where each user message is processed through an `inlet` to inject relevant memories, then passed to the language model, and the reply is post‑processed by an `outlet` to capture new emergent information, repeating turn‑by‑turn to keep context while safeguarding privacy. Memories reside in a PostgreSQL “source‑of‑truth” table and a pgvector vector store; each user and each folder has its own collection (`user‑memory‑{user_id}` and `folder‑memory‑{folder_id}`) and embeddings are generated with the 384‑dimensional `all‑MiniLM‑L6‑v2` model. Retrieval is handled by `get_relevant_memories`, which embeds the query, pulls `reranking_top_k` candidates, converts raw cosine similarity to relevance scores, and immediately accepts candidates above `llm_skip_relevance_threshold` (0.93), otherwise optionally invokes the LLM for refinement when the score exceeds `vector_similarity_threshold` (0.7), and then applies a 60‑day half‑life time‑decay function with 20 % recency weight so newer memories are favored. This tiered strategy limits LLM calls, keeps vector search (~10 ms) and overall latency low (70 % reduction observed). To control memory bloat, a nightly background summarization routine clusters memories older than seven days (using embeddings, tags, or a hybrid), summarizes each cluster into a new memory, deletes the originals, and triggers additional summarization rounds when the count nears a 200‑memory cap, freeing ~40 slots when usage exceeds 80 % capacity. Core memories are regenerated at login by summarizing the most recent 50 memories (minimum 5 to avoid hallucinations) into a 1–2 paragraph bio inserted into every system prompt via `<userMemories>`. Duplicate prevention uses a two‑stage pipeline: an approximate `SequenceMatcher` ratio > 0.95 and, if embeddings are enabled, semantic cosine similarity > 0.97; matched entries are skipped. AdaptiveMemoryFilter maintains three fixed‑size LRU caches (embeddings, relevance scores, reverse lookup) to bound growth and invalidate stale data. Collaborative chats enforce Rule 1, allowing only “Interaction Patterns” and “Project Memory” banks via `get_collaborative_allowed_banks`, ensuring personal memories are never extracted. The overall design emphasizes fast tiered retrieval, structural privacy through distinct collection names and bank filtering, pre‑indexed core memories to eliminate vector‑search latency, continuous background maintenance, and user control via CLI commands, demonstrating that layered trade‑offs, fast paths, privacy safeguards, and background operations enable efficient scaling in multi‑user environments.
Keywords: #gpt-oss:20b-cloud, AdaptiveMemoryFilter, All-MiniLM-L6-v2, Async, Caching Strategy, Core Memories, Decay, Group Chat, LLM, Latency, Memory, PostgreSQL, Privacy, Rust, Summarization, TypeScript, Vector Search, pgvector
cochat.ai 14 days ago
|
2646.
HN
Ktkit: A Kotlin toolkit for building server applications with Ktor
KtKit is an early‑stage, open‑source Kotlin multiplatform toolkit designed to accelerate Ktor server development by bundling essential infrastructure: a lightweight bootstrap with dependency injection via Koin, JSON handling, and automatic REST‑handler registration; a standardized request flow that incorporates tracing, authentication and authorization hooks, RFC‑9457‑style error formatting, and ready‑to‑use health and metrics endpoints; a robust TOML‑based configuration loader that supports environment‑variable interpolation and merging of files and resources; and a collection of convenience utilities for retry logic, JSON/TOML handling, and KMP‑friendly file, HTTP, and process APIs. The toolkit adopts a functional style using Arrow’s Raise/Either and Kotlin context parameters to streamline error handling, and it includes planned integrations such as Arrow resilience primitives (retry, resource, circuit breaker), extensive documentation and examples, JWT/Bearer extraction, X‑Real‑Name header authentication, and database/queue adapters (e.g., sqlx4k, PGMQ). The core module (ktkit core) consolidates server plumbing (startup/shutdown, JSON, Koin DI, routing), an abstract REST handler (typed requests, context propagation, RFC‑9457 error modeling, health/metrics endpoints), and a TOML config loader with environment substitution. The Ktor HTTP client abstraction (ktkit‑ktor‑httpclient) provides factory‑based pre‑configured clients, an abstract REST client with typed methods, and concrete implementations—BearerRestClient and XRealNameRestClient—that manage authentication and expose a sealed error hierarchy. The sqlx4k integration (ktkit‑sqlx4k) delivers coroutine‑friendly SQL with compile‑time query validation across PostgreSQL, MySQL/MariaDB, and SQLite, along with DatabaseService helpers for error mapping, traced transactions, and auditing hooks through an AuditableRepository, and it’s extendable to PGMQ for event handling. Build examples illustrate setting up a multiplatform Gradle project, Docker‑Compose configuration for PostgreSQL, and ergonomic design that uses Arrow’s Raise and Kotlin’s context‑parameter syntax to carry trace and request metadata via an ExecContext, while encouraging community contributions and connecting to related projects such as log4k and sqlx4k.
Keywords: #gpt-oss:20b-cloud, Arrow, DI, Docker, JWT, Kotlin, Ktor, Multiplatform, PGMQ, PostgreSQL, REST, SQLite, SQS, sqlx4k
github.com 14 days ago
|
2680.
HN
Show HN: Chitram – Open-source image hosting with automatic AI tagging
Chitram is an open‑source image‑hosting platform that automatically tags uploaded pictures with the GPT‑4o‑mini Vision model. Built with FastAPI, PostgreSQL, MinIO (S3‑compatible), Celery, Redis, and Docker, it processes uploads by running a Celery worker that forwards the image to the OpenAI Vision API, stores the returned tags in Postgres, and completes the request in roughly ten seconds at an approximate cost of $0.004 per image. Developed as a learning project, the author addressed real‑world distributed‑systems concerns such as provider swapping, asynchronous task handling, and background‑worker testing; the most challenging bug involved a hidden DB‑session duplication that caused production failures while tests continued to pass. The source code, usage demo at chitram.io, and in‑depth blog posts are available on GitHub and the author’s blog, and the project serves as a showcase for a transition into AI‑automation engineering.
Keywords: #gpt-oss:20b-cloud, AI tagging, Celery, Celery workers, Chitram, Docker, FastAPI, GPT-4o-mini, MinIO, MinIO storage, OpenAI, OpenAI Vision, PostgreSQL, Redis, Redis caching, basic CRUD, deployment debugging, distributed systems, image hosting, incremental complexity, new complexity, phase added, system design, valuable lessons, vision
chitram.io 14 days ago
|
