Agent Craft
Learn full-stack AI agent development through runnable, progressive Python examples.
Per-dimension scores and reasoning
least_privilege=1: The README says most API keys are optional, but it does not establish least-privilege policies for tools, networking, files, or MCP access. user_confirmation=1: Human-in-the-Loop is taught, but there is no evidence that every externally consequential example requires confirmation. data_flow_transparency=1: The module map names LLM, RAG, LangSmith, and MCP flows, but does not enumerate what data is transmitted, to whom, or how it is stored and retained. sensitive_data_handling=1: An environment template and placeholder keys are provided, without guidance on log redaction, rotation, leak response, or commit prevention. dependency_security=1: Most packages are pinned, but two use minimum-version ranges; CI has no vulnerability scanning, lockfile verification, or update policy and uses older major versions of checkout/setup-python. external_effects=1: Tool calls, public MCP services, maps, and remote APIs are disclosed, but side effects, authorization boundaries, and safe defaults are not specified. rollback=0: No undo procedure, state restoration, or compensating transaction is documented. source_attribution=2: Modules, companion articles, frameworks, and the copyright holder are identified; a fuller third-party attribution inventory and verified maintenance identity are absent.
self_consistency=2: The README, requirements, and CI generally align around Python 3.10–3.12 and the advertised stack. Deductions reflect module 13's detailed section repeating Swarm/Handoff content instead of its stated Streamlit content, and OPENAI_API_KEY being described as a DeepSeek key. dependency_availability=2: A centralized requirements file, installation commands, and CI installation across three Python versions are present. There is no lockfile, two dependencies allow version drift, and CI invokes the legacy resolver. failure_messages=0: The supplied material shows no user-facing error taxonomy, diagnostic messages, or recovery guidance.
audience_and_scenarios=3: The intended learner is explicit, and scenarios are thoroughly arranged by difficulty and objective across prompting, tools, RAG, graphs, multi-agent coordination, MCP, and UI development. capability_boundaries=2: The educational scope, availability of modules 01–13, unfinished modules 14–15, and optional keys are disclosed. Production suitability, security boundaries, and performance limits are not systematically defined. trigger_precision=1: Chapters and tool topics are separated clearly and human approval is mentioned, but there is no repository-wide contract for agent triggers, tool-selection constraints, or ambiguity handling. environment_fit=2: Python and Node.js versions, setup commands, and environment variables are specified; OS differences, hardware needs, containers, and an external-service compatibility matrix are absent.
information_architecture=3: The module table, difficulty ratings, objectives, progressive learning path, and quick start provide a thorough and navigable teaching structure. install_notes=2: Clone, dependency, editable-install, key-configuration, and first-run instructions are present; virtual environments, common failures, and platform-specific notes are missing. naming_stability=2: Numbered directories and topic names are mostly stable, but capitalization varies and module 13's detailed description conflicts with its title. examples_and_faq=2: Independent examples, a first command, and extensive learning guidance are presented; no FAQ, expected outputs, or troubleshooting examples appear in the supplied evidence. known_limitations=1: Unfinished modules and optional keys are acknowledged, but security, cost, quality, scaling, and production limitations are not catalogued. license=3: The full MIT license includes copyright, conditions, permissions, and warranty disclaimer. versioning_changelog=0: No releases, changelog, migration notes, or compatibility history are shown. maintenance_responsibility=1: Issue/PR channels, a blog, direct contact, and an intent to continue updating are given; maintainer identity is unverified and no maintenance cadence, support commitment, or security-reporting route is defined.
output_usability=2: Modular runnable examples and a Streamlit-oriented practical module support ordinary educational use, but the evidence provides neither representative outputs nor acceptance criteria or production deliverables. marginal_value=2: The progressive combination of LangChain, RAG, LangGraph, MCP, and Agents SDK offers value beyond isolated snippets; the unfinished capstone and deployment modules reduce end-to-end value. cost_benefit=1: Open source MIT licensing and a mostly optional key setup lower entry cost, but expenses and resource demands for model calls, external services, vector tooling, and local execution are not estimated.
claim_traceability=2: Claims map to numbered modules, dependency entries, companion articles, and CI configuration. Strong claims such as runnable and one-command reproducibility are supported only by compilation checks, not behavioral static-test evidence. cross_source_corroboration=2: The README's stack is broadly corroborated by requirements, CI, and the MIT license; CI performs installation, compilation, and limited linting rather than tests that substantiate functionality. fact_inference_separation=1: No executed results are fabricated and unfinished chapters are labeled, but marketing statements, planned content, and verified capabilities are not sharply separated; the CI badge could be mistaken for functional-test evidence.
- This assessment is based only on the supplied static files; no examples were run and no API or third-party service behavior was verified.
- Before using tool calls, public MCP servers, LangSmith, maps, or model APIs, inspect actual data transmission, permission scope, logging, and side effects, and require explicit approval for writes.
- Do not treat the CI badge as evidence of functional correctness: the workflow primarily checks dependency installation, compilation, and limited linting, with no behavioral tests.
- Use an isolated environment and review dependencies; minimum-version ranges, the legacy resolver, and the absence of a lockfile can produce different environments over time.
- Keep real credentials only in uncommitted local configuration and add secret detection, log redaction, rotation, and revocation procedures.
- Modules 14–15 are unfinished, and module 13's detailed description conflicts with its title; inspect each directory and expected output before adoption.
What does this agent do, and when should you use it?
Agent Craft is a beginner-oriented Python curriculum that progresses from basic model calls to interactive agent applications. Its 13 currently available modules cover prompts, LLM APIs, function calling, LangChain, RAG, LangGraph, MCP, the Agents SDK, Swarm, and Streamlit. Exercises include conversational memory, external function execution, FAISS and Chroma retrieval, reranking, ReAct, human approval, graph composition, and multi-agent orchestration. The MCP track builds a FastMCP server and a langchain-mcp-adapters client using Stdio or Streamable HTTP. The latest available module connects Agents SDK examples to a Streamlit interface with asynchronous event streaming and session persistence, while the planned integrated project and deployment modules remain unfinished.
The path begins with the model call in m01_agent_introduction/Agent-demo.py, then introduces prompts, multi-turn context, and Function Calling. The LangChain modules combine LLM, Prompt, Chain, Memory, @tool, ReAct, SQL Agent, caching, and streaming to create agents that can invoke tools. The RAG lessons load and split text, create embeddings, store vectors in FAISS or persistent Chroma, and retrieve context through an LCEL RAG chain; advanced material adds a Reranker and exposes retrieval as a tool. LangGraph examples express state and decisions as graphs, with LangSmith tracing, persistent memory, prompt-safety injection, Human-in-the-Loop, Graph-as-a-Tool, and Multi-Agent orchestration. The MCP lessons implement a FastMCP server supporting Stdio and Streamable HTTP, then connect a streaming client with langchain-mcp-adapters and AsyncExitStack. Agents SDK and Swarm examples coordinate customer-service agents through Handoff and Context_variables, and the Streamlit module supplies the interactive chat layer through st.chat_message, asynchronous events, and persistent sessions.
- A Python beginner who wants a sequential path from environment setup and a first API call to tool-using agents.
- An API user who can call models but wants runnable examples of ReAct loops, state graphs, handoffs, and agent decision flow.
- A developer prototyping question answering over private documents with text splitting, embeddings, FAISS, Chroma, reranking, and LCEL.
- An engineer learning MCP who needs examples of both a FastMCP server and clients using Stdio or Streamable HTTP.
- A team exploring controlled workflows through Human-in-the-Loop approval, Graph-as-a-Tool, and multi-agent orchestration.
- A developer building a customer-service prototype with Agents SDK, Swarm, and a Streamlit chat interface.
What are this agent's strengths and limitations?
- The curriculum provides a continuous, modular path from a minimal LLM call through RAG, LangGraph, MCP, multi-agent coordination, and Streamlit.
- Each released module is designed to run independently and is paired with commented examples and a detailed CSDN article.
- The RAG track covers FAISS, Chroma, and reranking, while the LangGraph track includes tracing, persistence, human approval, and multi-agent workflows.
- The MCP material covers both server and client implementation, including FastMCP, langchain-mcp-adapters, Stdio, and Streamable HTTP.
- Only modules 01–13 of the planned 15-module path are available; the integrated project and deployment conclusion are unfinished.
- A working LLM API credential is required, and selected exercises add dependencies on LangSmith, Amap, or ChatGPT services and credentials.
- The documented environment requires both Python 3.10–3.12 and Node.js v20+, adding setup overhead even for users focused on individual Python lessons.
- The supplied material gives no production deployment procedure, reliability figures, test-coverage evidence, or operating-cost benchmarks.
How do you install or deploy this agent?
The documented runtime is Python 3.10–3.12 with Node.js v20+. Run:
git clone https://github.com/Annyfee/agent-craft.git
cd agent-craft
pip install -r requirements.txt
pip install -e .Then run cp .env.example .env and configure at least OPENAI_API_KEY. Depending on the example, you may also need LANGCHAIN_API_KEY, AMAP_MAPS_API_KEY, or CHATGPT_API_KEY. Examples that contact these external services require network access.
How do you use this agent?
After installing the package and configuring .env, start the first example with:
python "m01_agent_introduction/Agent-demo.py"Continue through the directories from m01_agent_introduction to m13_streamlit; each released module is presented as an independent unit with code, explanation, and examples. Supply the optional LangSmith, Amap, or ChatGPT credentials only for exercises that use those services. Modules 14 and 15 are still marked as in progress, so the source does not provide a finished integrated-project workflow or production deployment command.
FAQ
Do I have to configure every listed API key?
OPENAI_API_KEY is documented as required for the LLM, while LANGCHAIN_API_KEY, AMAP_MAPS_API_KEY, and CHATGPT_API_KEY are optional and depend on the exercise.