Agent Craft: a 15-module Python course that builds an agent stack from raw LLM calls to MCP

The gap Agent Craft targets: knowing the words without having run the loop

The README states the problem in its own terms: learners get stuck at the point where they know the concepts but cannot build, or can call an API but do not understand the mechanism. That is a real and specific failure mode in agent development, because the distance between a working chat completion and a working agent is mostly plumbing. Tool schemas have to be declared, the model's tool call has to be parsed, the function has to run, the result has to be fed back, and the loop has to terminate. Each step is small. Skipping any of them leaves you with a demo that only answers questions.

The intended audience is a Python developer who has not assembled that loop before. The module list is ordered accordingly: m01_agent_introduction covers environment setup and a minimal agent, m02_llm_fundamentals covers model calls, prompt construction and multi-turn memory, and m03_function_calling_tools covers wrapping a Python function so the model can invoke it. Only after those three does the repository move to LangChain in m04 and m05. That ordering is the product. A reader who jumps straight to m09_langgraph_advanced will meet Human-in-the-Loop and Graph-as-a-Tool without the mental model the earlier modules are meant to install.

The repository is not a library. There is no installable package described in the material, no published release, and no API that other code depends on. It is a set of independent directories, each with code, an explanation, and examples, and each runnable on its own according to the README. Treat it as a curriculum, and the shape makes sense. Treat it as a framework, and you will be looking for something that was never promised.

How the modules are laid out and what each one hands you

Fifteen modules are listed, grouped into five bands. The foundation band holds m01 through m03. The framework band holds m04 through m09 and is where most of the volume sits: LangChain basics and advanced, RAG basics and advanced, then LangGraph basics and advanced. The intelligence band holds m10 and m11 for MCP server and client work, plus m12 for the Agents SDK and the Swarm pattern. The practice band holds m13, a Streamlit introduction built around a customer-service dashboard example. The engineering band holds m14 and m15.

The RAG pair is split in a way that reflects a real progression rather than a topic list. m06_rag_basics covers loading and splitting text, embedding, storing vectors in FAISS, and assembling an LCEL RAG chain. m07_rag_advanced moves to Chroma for persistence, adds a reranker stage, turns retrieval into a tool, and integrates the six LangChain modules covered earlier. The reranker is the interesting addition, because it is the step most tutorials omit: retrieving candidates by vector similarity and then reordering them before they reach the prompt is a different pipeline from plain top-k retrieval, and the module treats it as a named stage.

The LangGraph pair follows the same pattern. m08_langgraph_basics covers the three core elements, debugging with LangSmith, a white-box ReAct loop, persistent memory, and prompt injection safety. m09_langgraph_advanced adds human approval, Graph-as-a-Tool, and multi-agent orchestration. The phrase white-box in the module description is the tell: the point is to write the ReAct cycle yourself rather than let an agent executor hide it, which is the only way the later orchestration material has anything to attach to.

Modules 14 and 15 are marked as in progress in the module table, with m14 described as combining LangGraph, RAG, MCP, Streamlit and Vercel, and m15 covering deployment with Ollama, LM Studio and LangServe. As of the last push recorded for the repository, the README says modules 01 through 13 are open. Plan around thirteen.

Running a module: what the repository expects from your environment

The material does not reproduce a full command transcript in the README, so the runnable details live inside each module directory. What can be established from the repository text is the shape of the setup. m01_agent_introduction is described as covering environment dependencies, API key configuration, and a minimal runnable agent. That means a Python environment, an API key supplied through configuration, and a first call to a hosted model.

The model side is OpenAI-compatible rather than OpenAI-only. The topics list includes deepseek and openai, and the engineering band names Ollama and LM Studio as local serving options for the deployment module. In practice that means the model endpoint and key are the two values you will be editing, and the same code path is expected to work against a hosted provider or a local server. If your provider does not implement the tool-calling format used in m03, the Function Calling module is where the course stops working for you, not later.

Beyond that, the concrete dependencies are the ones the module names imply: langchain and langgraph for the framework band, faiss for m06, chroma plus a reranker for m07, langchain-mcp-adapters for m11, fastmcp for m10, and streamlit for m13. The README does not pin versions in the text, and no releases are recorded for the repository, so version drift between the modules and current library releases is the first thing to check. A CI workflow exists (the README carries a Python CI badge pointing at .github/workflows/ci.yml), which suggests at least some modules are exercised automatically, but the README does not state which ones or against which versions.

The modules are described as independently runnable, so you do not need to execute all thirteen in sequence to use one. You do need to read them in sequence for the concepts to land, which is a different constraint.

The Chinese-language coupling is the biggest practical constraint

Every module links to a companion blog post on CSDN, and the README describes the relationship plainly: code that runs, plus prose that explains the design reasoning and key mechanisms. That pairing is the actual teaching method. The code comments and the explanations are in Chinese, and the blog is the place where the why lives.

This matters more than it first appears. The repository's stated second principle is that the principles should be understandable, and the mechanism for that is the blog. A reader who cannot read the posts is left with the code and whatever the inline comments carry. For m02 or m04 that is survivable, because the code is short and the libraries are documented elsewhere. For m08 and m09, where the point is to expose the ReAct loop and then wrap graphs as tools, the explanation is doing real work. You can reconstruct it from the code, but you are no longer using the resource as designed.

The blog is also an external dependency. It is hosted on a third-party platform, not in the repository, so the explanations are not versioned alongside the code and cannot be diffed when a module changes. If a blog post is edited or moved, the repository gives no signal. That is a structural weakness of the teaching format, not a defect in the code, but it is the kind of thing worth knowing before you plan a study schedule around it.

Where Agent Craft is the wrong tool

The clearest boundary is production use. Nothing in the material describes a supported package, a versioning policy, a changelog, or a release artifact. The modules are teaching programs. Copying an m11 MCP client into a service means you own the async connection handling and the transport details yourself, with no upstream to file against. If you need an agent runtime with a compatibility promise, this repository is not it.

The second boundary is currency. Agent frameworks in this space change quickly, and the course spans nine distinct libraries or services across thirteen open modules. The README does not pin versions, and the repository shows no releases. A module written against one LangGraph API may not run against the next minor version, and the failure will look like your mistake rather than drift. The two places this bites hardest are m09, where graph composition APIs are involved, and m11, where langchain-mcp-adapters mediates between two moving projects.

The third boundary is scope. The README lists fifteen modules and marks the last two as unfinished. The comprehensive project that ties LangGraph, RAG, MCP, Streamlit and Vercel together, and the deployment module covering Ollama, LM Studio and LangServe, are both still being written. If your goal is specifically to ship an agent to a hosting provider, the course currently stops one step short of that, and the material does not say when it will close the gap. Anyone whose interest is deployment rather than construction should check the module table before starting.

How it compares to LangChain's own tutorials and to a framework quickstart

The obvious alternative is the official documentation and tutorial track for LangChain and LangGraph. Those are maintained by the projects themselves, so they track the current API and are translated into multiple languages. Their structure, however, is reference-shaped: pages are organized by concept and you assemble your own path. Agent Craft inverts that. It fixes an order, starts below the framework at raw model calls, and only introduces LangChain once you have written the tool loop by hand in m03.

That inversion is the substantive difference. A framework quickstart shows you the shortest path to a working agent using that framework's abstractions. Agent Craft shows you the loop first and the abstraction second, which is why m08 describes a white-box ReAct implementation rather than an agent executor. If you have ever debugged an agent and could not tell whether the problem was your prompt, your tool schema, or the executor's internal routing, the white-box approach is the answer to that specific frustration. If you just need something running this afternoon, it is a detour.

A second alternative is a single end-to-end project tutorial, the kind that builds one application across many posts. Agent Craft is the opposite: thirteen independent directories, each runnable alone, with the integration deliberately deferred to m07 and to the unfinished m14. That makes it better for reference and worse for momentum. You can open m06 when you need to remember how the FAISS index is built. You cannot follow it the way you follow a build-along series, because there is no single artifact accumulating at the end.

The comparison that matters most is against doing nothing structured at all. The cost of the unordered path is that you learn LangGraph before you understand what a tool call is, and then the graph makes no sense. Agent Craft's ordering is its main contribution, and it is a contribution that the official docs do not make because they assume you arrive knowing what you want.

Licence, maintenance and what the repository costs you over time

The repository is MIT-licensed. That permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. It is a permissive licence, and it is the same licence most of the libraries the course teaches use, so there is no friction in copying a module's code into your own project. This is a description of the licence text, not legal advice; if you are redistributing the material or shipping derived code, read the LICENSE file in the repository and get your own counsel where it matters.

The licence covers the code. It does not obviously cover the blog posts, which live on a third-party platform and are governed by that platform's terms, so quoting or republishing the explanations is a separate question from reusing the Python.

Maintenance cost is where a teaching repository differs from a library. There is nothing to upgrade in Agent Craft itself; there is no dependency to bump. The cost is that the modules are pinned to whatever library versions were current when each was written, and the material gives no migration notes. When LangChain or langgraph-mcp-adapters change an API, the affected module becomes a puzzle rather than a lesson, and your job shifts from learning the concept to reconciling the code with the current docs. Budget for that, especially in the framework band.

A CI workflow exists, which is a positive signal that the code is at least executed somewhere, but the README does not say which modules the workflow covers or which dependency versions it installs. That is the gap to close before you invest a weekend: check the workflow file and the module requirements, and confirm the versions still install. The last recorded push to the repository is in August 2026, so the project is active rather than abandoned, but activity is not the same as version currency.

Who should work through this, and the first thing to check

Work through Agent Craft if you are a Python developer who has shipped ordinary applications but has not built an agent, and you want the loop demystified in a fixed order before you touch a framework. The sequence from m01 to m09 is the reason to choose it over the official docs, and the hand-written ReAct loop in m08 is the single most useful thing in the repository for someone who has been debugging agents they do not understand.

Skip it if you need a production runtime, if you cannot read Chinese and are unwilling to reconstruct the explanations from code and library docs, or if your target is deployment rather than construction, since m14 and m15 are unfinished. Skip it too if you need a pinned, reproducible dependency set, because the repository does not provide one.

Before you start, open the CI workflow at .github/workflows/ci.yml and the requirements file inside m03_function_calling_tools and m08_langgraph_basics. Confirm the pinned LangChain and LangGraph versions install on your Python, and confirm your model provider supports the tool-calling format that m03 depends on, since every later module builds on that one call path. If those two checks pass, the ordering will do the rest of the work.

Editorial conclusion

Adopt Agent Craft if you already write Python and want a fixed sequence of small runnable programs that ends with a multi-agent graph and an MCP client, and if reading Chinese prose alongside the code is acceptable to you. Do not adopt it as a production dependency, as a packaged framework, or if you need a stable API surface, because it is a course whose modules are meant to be read in order rather than imported. Before committing time, open m08_langgraph_basics and m11_mcp_advanced, confirm the pinned LangChain and langchain-mcp-adapters versions still resolve on your Python, and check whether your model provider supports the Function Calling path used in m03.

Official sources

1. Annyfee/agent-craft on GitHub
2. Issues
3. License: MIT
4. Project website
5. README