Browse

Prefer the simplest architecture that works; add structure only when it earns its cost.

Tool use, agent architectures, memory, and guardrails for autonomous LLM systems.

Attention lets each token gather information from the tokens most relevant to it.

Step-by-step reasoning helps on multi-step tasks but isn't a truthfulness guarantee.

Chunk size trades precision against context; structure-aware splits beat blind ones.

Embeddings map text to vectors so that similar meaning means nearby points.

Evaluate retrieval and generation separately; faithfulness is the metric that matters.

Offline harnesses, LLM-as-judge, and regression gates for LLM systems.

Zero-shot for capable models on clear tasks; few-shot to pin down format or nuance.

What an LLM is, tokens, embeddings, attention, and sampling — the core ideas.

Foundational papers and lasting resources, as plain text links.

Short definitions of key LLM terms, each linking to a fuller explanation.

Constrain what an agent can do, keep humans in the loop for risky actions, and log everything.

Jailbreaks coax a model past its guidelines; defend in layers and at the app boundary.

Build a labeled test set and score against it; pick metrics that match the task.

A model can grade open-ended output cheaply; guard against its known biases.

How to reason about model choice — a durable framework, not a spec sheet.

A harness runs your system over a fixed dataset and reports scores reproducibly.

What a new team member reads and sets up in week one.

Minimize sensitive data in prompts, never train on it, and scrub logs and outputs.

Planning decomposes goals; memory manages what the model can see across a long task.

Role, task, constraints, delimiters, examples — clear specification beats tricks.

A model can't reliably tell instructions from data; isolate untrusted content and limit privilege.

Prompt patterns, structured output, few-shot vs zero-shot, and chain-of-thought.

Ingest and index once; then retrieve, assemble a prompt, and generate per query.

An agent loops: reason, call a tool, observe the result, repeat until done.

Probe your system adversarially, turn findings into regression tests, and repeat.

A glossary, a model-family cheat sheet, and a curated further-reading list.

Fail the build when a change lowers quality below a baseline; keep the gate offline.

Retrieve broadly, then rerank with a stronger model to put the best chunks first.

RAG feeds relevant documents into the prompt so the model can answer from them.

Prompt injection, secret handling, jailbreaks, and red-teaming.

Decoding turns the model's next-token distribution into actual output tokens.

Constrain the format with schemas and validation, not just polite requests.

Start here — a map of the whole library and how the sections fit together.

A transformer is a stack of identical blocks — attention plus a feed-forward net.

Tokens are subword chunks; they drive cost, limits, and some surprising bugs.

A vector DB does fast approximate nearest-neighbor search over embeddings.

An LLM is a function that predicts the next token; everything else follows.