Books

Language models guess. Knowledge graphs know. Rusty Graph shows you how to build a local AI agent whose memory is a real knowledge graph — typed, validated, reasoned over, and queryable with SPARQL — all inside a single static Rust binary. No JVM. No Docker sidecar. No Python runtime bolted to the side. You will build Ares a research-assistant agent that observes papers, forms beliefs, makes promises to other agents, and tracks the provenance of every fact it holds. Chapter by chapter, Ares grows from an empty Cargo workspace into a full pipeline: > load → reason → validate → query → answer All of it in under a thousand lines of idiomatic Rust, using three crates that actually work today: `oxigraph`, `reasonable`, and `rudof_lib`. `grapfeo` You will learn how to- Model a domain as RDF triples and load them into an embedded store. - Write RDFS and OWL 2 RL axioms that infer trust, identity, and inverse relationships — automatically. - Guard your graph with SHACL shapes that reject bad data at the boundary, not in production. - Query everything with SPARQL, from simple lookups to federated queries across named graphs. - Wire the graph into a hybrid RAG pipeline so your LLM answers are grounded in facts, not vibes. Who it is forRust developers building agents, assistants, or any system where the answer "the model said so" is not good enough. You should be comfortable with Cargo and traits. You do **not** need any prior semantic-web background — every concept is introduced through Ares before any formal definition appears. Why Rust, why nowLocal agents are the next deployment target: a user's laptop, a Raspberry Pi, a WASM sandbox. Python cannot go there comfortably. Rust can. This book is the missing manual for the Rust side of the semantic web — the one that tells you exactly which crates work, where the ecosystem is thin, and how to ship anyway. Stop hoping your model tells the truth. Give it a graph that does.

This book provides an introduction to the high-level concepts behind query engines and walks through all aspects of building a fully working SQL query engine in Kotlin.

Learn databases from the bottom up by coding your own, in small steps, and with simple Go code (language agnostic).Atomicity & durability. A DB is more than files!Persist data with fsync.Crash recovery.KV store based on B-tree.Disk-based data structures.Space management with a free list.Relational DB on top of KV.Learn how tables and indexes are related to B-trees.SQL-like query language; parser & interpreter.Concurrent transactions with copy-on-write data structures.

What if you could build a graph database the way SQLite is built to disappear into an application? This book takes you inside the engine, from storage pages and transactions to traversal, queries and crash recovery. With complete working code, you’ll build a fast, durable embedded graph database from the ground up.

Your ORM works until it doesn't: a query returns ten thousand duplicated rows, a migration refuses a partitioned table, or the feature the product needs is one PostgreSQL has had for years. Twenty-one chapters that close the gap — LINQ translation, query plans, JSONB, full-text search, PostGIS and pgvector, then auditing, multi-tenancy and deployment. Every listing run against a live database. Every output captured, never typed.

RAG, Agent Bricks, the Multi-Agent Supervisor with MCP, Lakebase, MLflow 3, Lakehouse Monitoring, Feature Store, Vector Search. Every AI surface Databricks shipped at GA in 2025 and 2026, taught by a practitioner, current to 2026. What you will learn - Build RAG pipelines with Vector Search, embedding models, and citation grounding- Ship Agent Bricks for classification and information extraction- Orchestrate specialist agents with the Multi-Agent Supervisor and MCP- Use Lakebase as the operational Postgres layer for AI apps and agents- Detect data and model drift with Lakehouse Monitoring; wire alerts to retraining- Manage the ML lifecycle with MLflow 3 and the UC Model Registry- Govern features across training and serving with Feature Store (offline + online)- Serve foundation and custom models with AI Gateway controls Who this book is for Data engineers, ML engineers, and AI/ML architects who know PySpark and the Databricks platform and now need to ship production AI. Volume 3 is the recommended prerequisite. Table of Contents 1. Databricks SQL in Production. Warehouses, materialized views, three latency signals (admission, compilation, execution), the full dashboard backend wiring.2. External BI: Tableau, Power BI, dbt. Performance tips that take a dashboard from sluggish to instant, dbt configuration at incremental scale, the seam between BI and the lakehouse.3. AI/BI Dashboards. Anatomy of a Lakeview dashboard, draft vs published flow, the Dashboard Agent's reliable patterns, the five-grant permission model.4. Genie: Natural-Language Analytics. Grounding sources, the priority rule, the SQL Genie actually writes, the questions Genie answers cleanly versus the ones that confuse it.5. AI SQL Functions. ai_query, ai_parse_document, ai_extract for PDFs and HTML, univariate forecasts, the daily cost math for production AI SQL pipelines.6. Model Serving. Endpoints, the three fields that decide capacity and cost, the chat-completion payload, the five moving pieces of a production recommender.7. Foundation Models. Five major providers, the External Models config, the vendor-swap pattern (Claude to Gemini in hours, not weeks), the three habits that keep swap cost low.8. Vector Search and RAG. Six delta-sync arguments, three chunking strategies compared, the RAG function your app imports, end-to-end answer evaluation with traces.9. MLflow 3 and UC Model Registry. Versions, aliases, tags (and what each is not for), five tracking calls and what each one writes, the experiment-to-production lifecycle.10. Feature Store. Why SDP is the right producer, the six-file project layout, four parity-failure classes between offline and online stores and what causes each.11. MLOps as a Practice. Seven sources every incident reads from, three deploy patterns (canary, shadow, blue-green), three retrain strategies, five golden signals for an ML endpoint.12. Lakehouse Monitoring: Drift Detection. Six monitor parameters, the loop from drift alert to retraining, what to do when the baseline table is missing.13. Distributed Deep Learning. Three signals that force distributed training, picking the flavor (data, model, hybrid) from the bottleneck, four pieces of GPU memory worked out for a 7B model.14. Agent Bricks. Declarative classification and information-extraction agents, eval-set ingredients, the pre-compute pattern that makes small seed sets work.15. Multi-Agent Supervisor and MCP. The supervisor build, synthetic-turn evaluation, three real conversations end to end, the auth-passthrough chain across child agents.16. Lakebase: Operational Postgres for AI. Five alternatives compared, sub-10ms reads for AI apps, the lineage from Delta source through SDP into Postgres and onward to the endpoint.17. Capstone: Retail Intelligence App. Ten stages, each anchored to an earlier chapter. The smoke test that confirms every stage of the platform is reachable, the new-data path through the recommender.18. Certification and What's Next. The certification paths that actually map to the book, and the reading list the on-call team uses when something breaks.

Build a working SQL database engine in C++20 -- from raw pages to a realquery executor -- one compilable, measured challenge at a time. Everyperformance claim is a benchmark you run yourself; every unit ends with areal bug, caught red-handed and fixed. Nothing asserted. Everythingdemonstrated.

Build real-world software by coding a Redis server from scratch.Network programming. The next level of programming is programming for multiple machines. Think HTTP servers, RPCs, databases, distributed systems.Data structures. Redis is the best example of applying data structures to real-world problems. Why stop at theoretical, textbook-level knowledge when you can learn from production software?Low-level C. C was, is, and will be widely used for systems programming and infrastructure software. It’s a gateway to many low-level projects.From scratch. A quote from Richard Feynman: “What I cannot create, I do not understand”. You should test your learning with real-world projects!

Explore the power of Rust with "Rust Projects: Write a Redis Clone". This hands-on guide takes you through building a Redis-inspired database from the ground up, introducing key programming concepts like TCP connections, the RESP protocol, and concurrency. Following the CodeCrafters challenge, this book gradually builds your skills, making complex topics accessible. Whether you're new to Rust or looking to deepen your understanding, this project-based journey offers practical, real-world insights into modern systems programming. The book contains 40% discount code for CodeCrafters.io!

What really happens when PostgreSQL executes your query? Follow a SQL statement through every stage of PostgreSQL's internal pipeline—from raw text to returned results—and gain the deep understanding that transforms how you write, tune, and debug database applications.

Stop only using databases — start understanding them. A living study of PostgreSQL internals for backend engineers: how pages, indexes, and WAL actually work, written clearly while learning, not after mastery.

When your database outgrows simple optimizations, it's time to think bigger. Lift the Elephant goes beyond query tuning to reveal actionable strategies for scaling PostgreSQL, from partitioning to high-availability architectures. Built on lessons from scaling Hubstaff, this is your playbook for navigating the challenges of database growth.

Entwickler:innen haben heute eine Vielzahl von Optionen, wenn es um die Wahl einer Datenbank für ihre Anwendung geht. Dieses Buch gibt einen Überblick über Datenmodelle, Konzepte zur Skalierung und Betriebsformen – von relationalen Systemen über dokumenten- und graphbasierte Ansätze bis hin zu Zeitreihen- und Vektordatenbanken. Es bietet Hilfestellung bei der Auswahl und Einordnung für unterschiedliche Anwendungsszenarien.

Most data engineering projects fail not because of technology—but because of design.Design-Driven Data Engineering reveals a powerful new approach: start with business design, shape clarity through information modeling, and only then build systems that scale. This book gives you the frameworks, blueprints, and real-world patterns to design architectures aligned with business value, analytics needs, and modern AI-era requirements. Whether you’re an engineer, architect, analyst, or technical lead, this guide shows you how to turn complexity into clarity—and build data systems that actually work.