RetroDeckRETRODECK

How to Learn AI Engineering: A Skill Map From API Calls to Deployed Agents

Learn AI engineering in five stages: model APIs, tokens and structured output; embeddings and RAG; tool calling and agents; stateful orchestration with LangGraph; then evals, cost, latency and deployment. Build one small project per stage, and learn each concept by hand before adopting a framework, so you can tell what the framework saves.

What the 8-hour course covers, and what this map adds

The seed for this page is the neonlearn channel's "AI Engineering Full Course", published 16 November 2026 and running about eight and a half hours. Its description lays out ten projects: a streaming chatbot on the Groq API with token counting, cost estimation and conversation summarization; an LLM sentiment classifier plus local zero-shot classification with Hugging Face; semantic search with Sentence Transformers; RAG over PDFs with Chroma and source citations; a LangChain agent with web search, custom tools and MCP; structured output into Pydantic models; memory with checkpointers and PostgreSQL; middleware for automatic summarization; a LangGraph write, review and revise loop; and a supervisor-style multi-agent system.

That is a solid build sequence. Its chapter list has no dedicated section on evaluation or deployment, which is where most production work goes. The map below follows the same order, groups it into five stages, and adds those missing pieces. For a narrower path focused only on agents, see the six-stage agentic AI course page.

Stage 1: model APIs, tokens and structured output

Start with a raw provider SDK and no framework. Learn the message format and system role, sampling parameters such as temperature and max tokens, streaming, and how tokenization turns text into the units you are billed for. Learn that the model is stateless: conversation history is something your code resends, so you need a policy for trimming it, such as a sliding window or a running summary, before the context window or the bill forces one on you.

Then make outputs machine-readable. Ask for JSON against a schema, validate it with Pydantic, and retry on failure. Learn when an LLM is overkill: for fixed-label classification, a small local model can be cheaper and fast enough.

Build: a command-line chatbot that streams, prints tokens and estimated cost per turn, and trims history. Then an extractor that turns emails into validated records, with a comparison of an LLM against a local zero-shot classifier on the same labels.

Stage 2: embeddings and RAG

Embeddings map text to vectors where similar meaning sits close together; cosine similarity measures how close. That single idea powers semantic search, deduplication, clustering and retrieval-augmented generation. Learn chunking, because how you split documents decides what can be found. Learn a vector store, metadata filters, grounded prompts that tell the model to answer only from supplied passages, and citations that point back to the source.

Most importantly, learn to measure retrieval separately from generation. If the right chunk is not in the top results, no prompt will save the answer.

Build: chat with your own documents, with citations, plus a small hand-written test set of questions and the passages that should answer them. Track how often the right passage is retrieved before tuning anything else.

Stage 3: tool calling, agents, and when to skip the framework

An agent is a model calling tools in a loop until a task is done. Write that loop yourself once: send tool definitions, parse the tool call, run it, return the result, repeat with a step limit. After that, frameworks stop being magic. LangChain's create_agent wraps the loop and adds middleware hooks, such as SummarizationMiddleware for long conversations and HumanInTheLoopMiddleware for approvals. MCP standardizes how tools are exposed, so one server can serve many clients.

Skip the framework when the task is a single call or a fixed pipeline, when you need to see and control every prompt, or when a dependency would outweigh the code it saves. Adopt it when you need its integrations, persistence or middleware and would otherwise rebuild them.

Build: a research agent with web search and one custom tool, written twice, once as a raw loop and once with create_agent. Compare code size, debuggability and token use.

Stage 4: LangGraph state machines, memory and multi-agent

LangGraph models a workflow as a graph: nodes do work, edges decide what runs next, conditional edges branch on state, and a shared state object carries data between steps. That makes loops explicit, so a draft, review and revise cycle can stop when quality is good enough or a cap is hit.

Persistence is the other half. A checkpointer saves graph state per thread_id, which gives short-term memory, resumable runs, human-in-the-loop pauses and time travel through past states. LangGraph's docs pair InMemorySaver for development with persistent checkpointers such as PostgresSaver for production, and use stores for long-term memory shared across threads.

Multi-agent designs, such as a supervisor delegating to specialists, are the last step, not the first. Each extra agent adds calls, latency and places to fail.

Build: a write, review and revise graph with an iteration cap and a Postgres checkpointer, then a supervisor with two specialists. Measure whether the second version is actually better.

Stage 5: evals, cost, latency and deployment

Evals. Build a test set from real inputs, score outputs with exact checks where possible and model-graded rubrics where not, and rerun it on every prompt, model or retrieval change. Read traces, not just scores: most failures show up in an intermediate step.

Cost and latency. Log input and output tokens per request and per step. The usual levers are shorter prompts, prompt caching for stable prefixes, routing easy requests to smaller models, capping agent iterations, and retrieving a few relevant passages instead of stuffing whole documents. That last lever is where a retrieval layer helps: RDK puts encrypted private chunks in front of the model, queried over MCP, the CLI or the Partner API, and cuts token spend 80 to 90 percent on repeated or reference-heavy work.

Deployment. Serve behind an API with streaming, timeouts, retries and rate limits. Keep secrets out of prompts and logs, add tracing, and guard tool permissions.

Build: wrap the stage 2 RAG app as a service with tracing, a token dashboard and an eval suite that runs in CI.

Frequently asked questions

What should be learned first in AI engineering?
Start with a raw model API: messages, system prompts, parameters, streaming, tokens and cost. Then structured output with schema validation. These fundamentals sit under every framework and agent, and learning them without a framework makes later tools easier to debug. Embeddings and RAG come next, then tool calling and agents, then orchestration, evaluation and deployment.
Do you need LangChain or LangGraph to be an AI engineer?
No, but knowing them helps. Many production systems call model APIs directly. LangChain is useful for its integrations, agent wrapper and middleware; LangGraph for stateful, looping workflows with checkpointing and human approval steps. Learn the underlying patterns by hand first so you can judge when a framework saves work and when it only adds a layer.
What is the difference between LangChain and LangGraph?
LangChain provides building blocks and a high-level agent constructor, create_agent, with middleware for behaviors like summarization and human approval. LangGraph is the lower-level runtime for explicit graphs of nodes and edges, with shared state, conditional branching, loops and checkpointers that persist state per thread. Use LangChain for standard agents and LangGraph when you need precise control over flow.
How long does it take to learn AI engineering?
It depends on your starting point. A developer comfortable with Python and APIs can work through the fundamentals and build the core projects, a chatbot, a RAG app and a tool-using agent, in a few focused weeks. Evaluation, cost control and deployment take longer, because they are learned on real systems with real users rather than tutorials.
What projects belong in an AI engineering portfolio?
A streaming chatbot with token and cost tracking, a structured extraction tool with validation, a RAG app with citations and a retrieval test set, a tool-using agent, and a stateful LangGraph workflow. The strongest portfolios add an evaluation suite and a deployed service with tracing, since those show production judgment rather than only tutorial completion.