Generative AI Engineering Lab

This is a lab, not a product, and it is presented as one. It contains runnable implementations of the pieces that agent and retrieval systems are assembled from: LangGraph workflows in four control-flow shapes, LangChain composition patterns, two retriever strategies that address distinct retrieval failures, two vector store backends, and two approaches to constraining model output to a schema.

Most published agent code is a single prompt loop. That works in a demo and falls apart in production, because real workflows branch, run steps concurrently, and need to produce output that downstream code can rely on.

The gap is rarely the model. It is control flow, retrieval quality and output contracts — three things that have to be understood at the level of implementation rather than the level of a diagram.

When an AI feature underperforms, the cause is usually structural: the wrong chunks were retrieved, a step that should have branched did not, or a free-text response was parsed with a regular expression that broke on the first unusual answer.

Being able to reach for the right primitive — a conditional graph, a multi-query retriever, a schema-constrained response — is what separates diagnosing those failures from guessing at prompt wording.

Workflow topology — sequential graphs for pipelines, parallel graphs for independent work that should not run serially, and conditional graphs for routing on state. Each is implemented rather than described.

Retrieval strategies — a multi-query retriever that reformulates a question into several phrasings to widen recall when a user's wording does not match the corpus, and a contextual compression retriever that strips irrelevant passages from retrieved documents before they consume context budget. They fix opposite problems: one raises recall, the other raises precision.

Storage — FAISS and Chroma implemented side by side, with document loaders and embedding models, so the trade-off between an in-process index and a persistent store is a measured choice rather than a default.

Output contracts — Pydantic models and TypedDict schemas that make a model return parseable, validated structures instead of prose that downstream code has to guess at.

State moves through a graph rather than through a single prompt. Each node owns one transformation, which makes a failing step identifiable instead of a whole prompt being suspect.

Retrieval is treated as a tunable component with its own quality problem, not as a lookup that either works or does not. Recall and precision are addressed by different strategies, deliberately.

Model output crossing into application code passes through a schema. A response that does not validate fails at the boundary rather than propagating a malformed value.

Workflow topologies are implemented as LangGraph notebooks so state transitions can be inspected step by step rather than reasoned about from a diagram.

Chains, loaders, models, retrievers, vector stores and structured-output approaches are organised as small standalone modules, each isolating one concept so it can be swapped or compared directly.

Both vector backends are implemented against the same interface, so switching between an in-process index and a persistent store is a configuration change rather than a rewrite.