Skip to content
Multigrid

Frameworks and SDKs

What each AI framework's core abstraction actually is, how a real project is structured around it, where the abstraction stops helping, and what it costs to leave.

There is no shortage of framework tutorials. Almost all of them are the quickstart from the README with more words, which means they go stale the week the library cuts a release and they never tell you the thing you actually need to know: what this framework’s central abstraction is, whether your application has the shape that abstraction was designed for, and what you are signing up to maintain.

These twenty pages are written the other way round. Each starts from the one idea the library is built on — a runnable, a state graph, a component pipeline, a compiled prompt, an OpenAI-compatible server — and works outward to how a project is laid out, where the abstraction runs out, and what the migration path off it looks like. Code appears where the surface has been stable for years, and where it has not, the page says so instead of guessing.

The order is not accidental. Start with whether you need a framework at all, and finish with how to get out of one without a rewrite. Those two pages are the frame for the eighteen in between.

When a Framework Earns Its Place

The four separable jobs an AI framework does, what each one costs you in lock-in, and a decision procedure that takes an afternoon rather than a quarter.

9 min read

LangChain: The Parts Worth Using

Build one document-QA app with LangChain, then strip it back, and see which imports earned their place and which were a for-loop with a class around it.

10 min read

LangGraph: An Agent as a State Machine

Nodes, edges, shared state and checkpoints — how LangGraph turns an agent into a resumable state machine, and how to restart a run that failed halfway.

10 min read

LlamaIndex for Document-Heavy Apps

The ingestion pipeline as LlamaIndex's real product — readers, nodes, metadata — and the four points where its query abstractions stop helping.

10 min read

The Vercel AI SDK End to End

The server core, the streaming protocol and the chat hook — how the three fit together in one deployed app, with tools and structured output.

10 min read

DSPy: Compiling Prompts Instead of Writing Them

Signatures, modules and optimisers — how DSPy turns prompt engineering into a search problem, and why the metric has to be written before anything else.

10 min read

Instructor and Structured Extraction

Treating a model as a typed function: how validation-error-as-retry works, how to design schemas a model can satisfy, and what retrying cannot fix.

9 min read

LiteLLM as a Provider Abstraction Layer

One call shape across providers with LiteLLM — the SDK, the proxy, what maps cleanly between providers and the fields that quietly do not.

9 min read

Haystack Pipelines for Search Applications

Haystack's component-and-connection model, why explicit wiring is checked before a run, and how to keep evaluation in the same pipeline as production.

9 min read

CrewAI and Role-Based Agent Teams

Agents, tasks and crews — what role assignment genuinely buys you, and the arithmetic showing where a crew multiplies the bill without improving much.

9 min read

Semantic Kernel for .NET and Java Teams

Why Semantic Kernel exists for enterprise .NET and Java estates: the kernel, plugins as annotated methods, and the platform integration paths.

9 min read

Hugging Face transformers: Load and Run a Model

From from_pretrained to generate, with the chat template, precision and device placement done right — and the memory arithmetic that predicts the fit.

10 min read

Serving a Model With vLLM

One GPU, one command, an OpenAI-compatible endpoint — and the four flags that decide whether it starts and how many requests it serves at once.

10 min read

llama.cpp From Source to First Token

Build it, get a GGUF, quantise it, run it — and read the timings llama.cpp prints, against a ceiling you can derive from your machine's memory bandwidth.

10 min read

Ollama in a Development Workflow

Ollama as a local development dependency: the everyday commands, Modelfiles, the two APIs it exposes, and switching local to hosted with one variable.

9 min read

Text Generation Inference in a Container

Running TGI as a container: the arguments that decide whether it starts, health checks that mean something, and why queue depth is the scaling signal.

9 min read

Sentence Transformers for Embeddings You Control

Encoding text into vectors you own: normalisation, batching, the query prefix most people miss, and fine-tuning on your own pairs.

10 min read

Tracing Your Own Calls With Langfuse

Instrumenting one app end to end — traces, spans and generations — and doing it through OpenTelemetry so the data stays yours rather than the vendor's.

9 min read

Writing an MCP Client, Not Just a Server

The client half of MCP: transports, the initialise handshake, discovery, and the permission model that decides whether a tool call is safe to make.

10 min read

Migrating Off a Framework Without a Rewrite

A strangler-fig plan for removing LangChain or any AI framework: inventory the four jobs it does, then cut at the seams in order, still shipping.

11 min read

Other topics