Artificial Intelligence

A clear, illustrated guide to large language models, covering key concepts and practical applications. Ideal for projects, interviews, or personal learning.

A leader at a company opens Slack one morning. The brief their virtual employee wrote looks normal: same headers, same prose voice, same cadence as every other brief that week. The last line ends mid-sentence. The API returned `stop_reason: "max_tokens"`. The system shipped it anyway. No exception. No log line. No retry. That bug doesn't look like the normal kind. This book is about why, and what to build instead.

Everything you really need to know in Machine Learning in a hundred pages.

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 textbook accompanies a year-long Discrete Mathematics course for Computer Science and AI students, covering classical topics such as combinatorics, graph theory, probability, logic, and set theory. It emphasizes applications across computer science and complements the standard curriculum with advanced topics in each chapter.

Master language models through mathematics, illustrations, and code―and build your own from scratch!

Skip the black-box frameworks. Build a production-grade AI coding agent from scratch in pure Python - cloud or local, tested with pytest, all in a single file.

Your C# skills are worth more today than they were a year ago — if you know how to put a language model in the loop. This book shows you how, with the Microsoft Agent Framework: real tools, RAG, multi-agent orchestration, plus the hosting, observability, and safety that separate a demo from a system you ship. Nineteen chapters. 120 runnable projects. No Python detours. Just C# and .NET 10.

Run Jev-style decision models on your own hardware with Ollaya. Learn how these fast, structured models differ from LLMs, then build real applications with typed outputs, Python, JavaScript and MCP. From first setup to production, this practical guide shows you how to make AI faster, cheaper and more private.

A hands-on guide to downloading, running, serving, and maintaining open-weight LLMs on your own machine (492 manuscript pages).

How to represent knowledge for LLMs and build memory for agents, I discovered Mark's work on semantic spacetimes. It's more of a theoretical framework from someone who came from physics. But actually, jumping to knowledge representation and reasoning, and trying to answer the question of how to build dynamic and complex systems—semantic spacetimes and promise theories are crucial for the future of agentic systems, in my belief.The semantic spacetime approach gives us answers on how to organize better memory and how to have better knowledge representation that could be understood quite well by LLMs. Vector embeddings actually create a lot of challenges—some spaces and some relations in vector embeddings simply don't exist. We all have this problem where "love my wife " and "hate my wife" while actually quite distant in practice, and also time and dynamics matter

The latest version of Rust (1.85) has some great new features, like async closures, more stable associated function return types, and const generics that are now mature enough to underpin serious numerical libraries. The linfa and smartcore ecosystems have developed into decent classical machine learning stacks. The Burn training framework feels native to Rust, not like it's been ported from it. The Candle makes it so that loading pre-trained transformer models is more of an engineering task than a research exercise. The crates that used to need all sorts of workarounds now just work.

Keyword search misses meaning. Vector search misses precision. This book shows you how to combine them into production systems that deliver both, with architecture patterns, model selection frameworks, evaluation methodology, and operational guidance grounded in primary research.

Build a complete LLM inference engine in C++ — from a blankproject to a working Transformer that loads a real model andgenerates text. Forged one challenge at a time, with teststhat prove every piece works before you move on.

Code Is the Side Effect"Software engineers are not primarily code writers. We are clarity traders — and that hasn't changed."You've seen the demos. The AI builds a whole feature from a sentence. The agent writes tests, fixes the failing ones, opens the PR. It's remarkable.Then you come back three months later. The codebase is a tangle. Nobody knows why anything is the way it is. The agent that built it has no memory of what it decided or why. And every time you ask it to add something new, it breaks two things you didn't know were connected.This is the pattern that nobody talks about. AI coding tools make the easy parts of engineering dramatically easier. They leave the hard parts untouched — and they create new hard parts that didn't exist before.Ways of Working is the book for engineers who want to work with AI agents rather than be gradually replaced by them — who understand that the tools are genuinely powerful and genuinely limited, and want to build practices that get the most from each.What you will actually learnThe world model framework. Before an agent can build anything well, it needs to understand what it's building and why. This book teaches you to give agents what they need: a structured, queryable representation of your architecture, your component contracts, your behavior specifications, and your code patterns. No world model = no sustained agentic development.Intent documentation. The most expensive bug in agentic codebases is not a hallucination — it's a decision made without context. Why is this rule here? Why is this boundary where it is? Agents can't infer rationale from code. You have to write it down.Spec-Kit and formal specifications. GitHub's Spec-Kit brings machine-readable, traceable, CI-verified specifications to engineering teams. This book shows how to use it to turn requirements into agent inputs that are precise enough to generate correct implementations.Graph explainers. Tools like Graphify and Understand-Anything transform codebases and documents into queryable knowledge graphs — giving agents navigable context instead of flat text. This is the memory substrate that makes multi-agent systems reliable at scale.Agent architecture that holds. What makes an agent coherently itself? When do file-based agent systems break down and what replaces them? How does constraint-based coordination (borrowed from holocracy) solve the autonomy-coherence problem that has stumped AI researchers for decades?Claude Code, for real. A complete treatment of Claude Code's CLAUDE.md convention, permission model, hooks, and slash commands. Plus the oh-my-claudecode ecosystem: 15+ specialized agents, workflow orchestration patterns (autopilot, ralph, ultrawork), and the skills framework for team-specific automation.The AI-native organization. What genuine AI-native teams look like beneath the marketing. How to hire, structure, and lead them. What language-oriented programming and constrained natural language mean for the future of the human-code relationship.Who it's forEngineers who are past the "should I use AI?" question and into the "how do I use it without losing my engineering integrity?" question.Senior engineers. Engineering managers. Technical leaders. People who have noticed that the more they delegate to AI, the less certain they feel — and who want to understand why.From the AuthorI've been building production systems with AI agents for years. Not demos — systems that had to work reliably across months, maintain themselves as requirements changed, and produce outputs that engineers could understand and defend.That experience has made me skeptical in both directions.Skeptical of the "AI will do everything" vision — because I've watched too many AI-generated codebases collapse under the weight of accumulated misunderstanding.Equally skeptical of the "nothing fundamentally changed" position — because the engineers who treat AI coding tools as just faster autocomplete are making a category error they'll pay for in months of maintenance debt.Something genuinely new is happening. This book is my attempt to think about it clearly.