ai-agents-from-zero-tutorial

# AI Agents From Zero Tutorial Skill > Skill by [ara.so](https://ara.so) — AI Agent Skills collection. ## Overview `ai-agents-from-zero` is a comprehensive, open-source Chinese tutorial system for building AI Agents from zero to enterprise-level deployment. It provides systematic learning paths covering LLM fundamentals, prompt engineering, low-code platforms (Coze/Dify), frameworks (LangChain/LangGraph/DeepAgents), RAG, MCP, and enterprise deployment with working code examples and real-world projects. **Key Features:** - Complete learning path from basics to enterprise deployment - Two full production projects with source code - Interview question bank aligned with AI Engineer job requirements - Python-focused with LangChain/LangGraph as primary frameworks - Covers low-code platforms (Coze, Dify) and enterprise RAG systems - Continuous updates with latest AI tech stack **Official Resources:** - GitHub: https://github.com/didilili/ai-agents-from-zero - Documentation: https://didilili.github.io/ai-agents-from-zero/ - Project 1 (Shopkeeper): https://github.com/didilili/shopkeeper-agent - Project 2 (DeepSearch): https://github.com/didilili/deepsearch-agents ## Installation & Setup ### Access the Tutorial ```bash # Clone the repository git clone https://github.com/didilili/ai-agents-from-zero.git cd ai-agents-from-zero # Access online documentation # Visit: https://didilili.github.io/ai-agents-from-zero/ ``` ### Project Dependencies For the tutorial examples and projects, you'll need: ```bash # Create virtual environment python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate # Install common dependencies pip install langchain langchain-community langchain-openai pip install langgraph pip install chromadb faiss-cpu pip install openai anthropic pip install python-dotenv pip install streamlit # For UI demos ``` ### Environment Configuration ```bash # Create .env file cat > .env << EOF # LLM API Keys OPENAI_API_KEY=your_openai_key ANTHROPIC_API_KEY=your_anthropic_key ZHIPUAI_API_KEY=your_zhipu_key # Vector Database CHROMA_PERSIST_DIRECTORY=./chroma_db # Model Settings DEFAULT_MODEL=gpt-4 TEMPERATURE=0.7 EOF ``` ## Tutorial Structure ### 1. LLM Fundamentals (大模型基础) **Topics Covered:** - LLM architecture (Transformer, MoE, Self-Attention) - Model deployment (Ollama, Xinference, vLLM) - Prompt engineering principles - Multi-turn conversations and memory **Example: Basic LLM Call** ```python from langchain_openai import ChatOpenAI from langchain.schema import HumanMessage, SystemMessage import os from dotenv import load_dotenv load_dotenv() # Initialize LLM llm = ChatOpenAI( model="gpt-4", temperature=0.7, api_key=os.getenv("OPENAI_API_KEY") ) # Create messages messages = [ SystemMessage(content="你是一个专业的AI助手，擅长回答技术问题。"), HumanMessage(content="什么是AI Agent？") ] # Get response response = llm.invoke(messages) print(response.content) ``` **Example: Prompt Engineering with Few-Shot** ```python from langchain.prompts import FewShotPromptTemplate, PromptTemplate # Define examples examples = [ { "input": "如何实现RAG系统？", "output": "RAG系统需要：1) 文档分割 2) 向量化存储 3) 相似度检索 4) 上下文增强生成" }, { "input": "什么是LangGraph？", "output": "LangGraph是一个图式工作流框架，用于构建复杂的AI Agent应用。" } ] # Create example template example_template = PromptTemplate( input_variables=["input", "output"], template="问题：{input}\n回答：{output}" ) # Create few-shot template few_shot_prompt = FewShotPromptTemplate( examples=examples, example_prompt=example_template, prefix="以下是一些技术问答示例：", suffix="问题：{input}\n回答：", input_variables=["input"] ) # Use the prompt prompt = few_shot_prompt.format(input="什么是MCP协议？") response = llm.invoke(prompt) print(response.content) ``` ### 2. Low-Code Platforms (低代码平台) #### Coze (扣子) Platform **Key Features:** - Workflow builder - Plugin system - Knowledge base integration - Agent orchestration **Example: Call Coze Workflow via Python** ```python import requests import os def call_coze_workflow(workflow_id, input_data): """Call Coze workflow API""" url = f"https://api.coze.com/v1/workflow/{workflow_id}/run" headers = { "Authorization": f"Bearer {os.getenv('COZE_API_KEY')}", "Content-Type": "application/json" } payload = { "input": input_data, "stream": False } response = requests.post(url, json=payload, headers=headers) return response.json() # Example usage result = call_coze_workflow( workflow_id="your_workflow_id", input_data={"query": "分析这个商品评论", "content": "商品质量很好"} ) print(result) ``` #### Dify Platform **Example: Dify Local Deployment with Docker** ```bash # Clone Dify repository git clone https://github.com/langgenius/dify.git cd dify/docker # Start services docker-compose up -d # Access Dify at http://localhost:3000 ``` **Example: Call Dify API** ```python import requests import os class DifyClient: def __init__(self, api_key, base_url="https://api.dify.ai/v1"): self.api_key = api_key self.base_url = base_url def chat_completion(self, query, conversation_id=None): """Send chat message to Dify""" url = f"{self.base_url}/chat-messages" headers = { "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json" } payload = { "query": query, "inputs": {}, "response_mode": "blocking", "user": "user-123" } if conversation_id: payload["conversation_id"] = conversation_id response = requests.post(url, json=payload, headers=headers) return response.json() # Usage client = DifyClient(api_key=os.getenv("DIFY_API_KEY")) response = client.chat_completion("如何优化RAG系统？") print(response["answer"]) ``` ### 3. LangChain & LangGraph Framework #### Basic LangChain Patterns **Example: Chain with LCEL (LangChain Expression Language)** ```python from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough # Create components llm = ChatOpenAI(model="gpt-4") prompt = ChatPromptTemplate.from_messages([ ("system", "你是一个{role}，请用专业的方式回答问题。"), ("user", "{question}") ]) output_parser = StrOutputParser() # Build chain using LCEL chain = ( {"role": RunnablePassthrough(), "question": RunnablePassthrough()} | prompt | llm | output_parser ) # Invoke chain result = chain.invoke({ "role": "AI工程师", "question": "如何设计一个电商智能客服系统？" }) print(result) ``` **Example: Memory with ConversationBufferMemory** ```python from langchain.memory import ConversationBufferMemory from langchain.chains import ConversationChain from langchain_openai import ChatOpenAI # Initialize components llm = ChatOpenAI(model="gpt-4") memory = ConversationBufferMemory() # Create conversation chain conversation = ConversationChain( llm=llm, memory=memory, verbose=True ) # Multi-turn conversation response1 = conversation.predict(input="我想构建一个RAG系统") print(response1) response2 = conversation.predict(input="需要哪些组件？") print(response2) # Check memory print("\n对话历史：") print(memory.load_memory_variables({})) ``` #### LangGraph State Machine **Example: Simple Agent with LangGraph** ```python from langgraph.graph import StateGraph, END from typing import TypedDict, Annotated from langchain_openai import ChatOpenAI import operator # Define state class AgentState(TypedDict): messages: Annotated[list, operator.add] current_step: str # Define nodes def analyze_intent(state: AgentState): """Analyze user intent""" llm = ChatOpenAI(model="gpt-4") prompt = f"分析用户意图：{state['messages'][-1]}" response = llm.invoke(prompt) return { "messages": [response.content], "current_step": "intent_analyzed" } def generate_response(state: AgentState): """Generate final response""" llm = ChatOpenAI(model="gpt-4") prompt = f"基于意图生成回复：{state['messages'][-1]}" response = llm.invoke(prompt) return { "messages": [response.content], "current_step": "completed" } # Build graph workflow = StateGraph(AgentState) # Add nodes workflow.add_node("analyze", analyze_intent) workflow.add_node("respond", generate_response) # Add edges workflow.set_entry_point("analyze") workflow.add_edge("analyze", "respond") workflow.add_edge("respond", END) # Compile app = workflow.compile() # Run result = app.invoke({ "messages": ["我想查询订单状态"], "current_step": "start" }) print(result) ``` ### 4. RAG System Implementation **Example: Complete RAG Pipeline** ```python from langchain_community.document_loaders import TextLoader from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_openai import OpenAIEmbeddings, ChatOpenAI from langchain_community.vectorstores import FAISS from langchain.chains import RetrievalQA from langchain.prompts import PromptTemplate # 1. Load documents loader = TextLoader("./data/knowledge_base.txt", encoding="utf-8") documents = loader.load() # 2. Split documents text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, chunk_overlap=50, separators=["\n\n", "\n", "。", "！", "？", "；", "，", " "] ) texts = text_splitter.split_documents(documents) # 3. Create embeddings and vector store embeddings = OpenAIEmbeddings(api_key=os.getenv("OPENAI_API_KEY")) vectorstore = FAISS.from_documents(texts, embeddings) # Save vector store vectorstore.save_local("./faiss_index") # 4. Create retriever retriever = vectorstore.as_retriever( search_type="similarity", search_kwargs={"k": 3} ) # 5. Create QA chain with custom prompt template = """使用以下上下文回答问题。如果不知道答案，请说"我不知道"。 上下文： {context} 问题：{question} 详细回答：""" prompt = PromptTemplate( template=template, input_variables=["context", "question"] ) llm = ChatOpenAI(model="gpt-4", temperature=0) qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", retriever=retriever, chain_type_kwargs={"prompt": prompt}, return_source_documents=True ) # 6. Query query = "如何优化RAG系统的检索效果？" result = qa_chain.invoke({"query": query}) print("回答：", result["result"]) print("\n来源文档：") for doc in result["source_documents"]: print(f"- {doc.page_content[:100]}...") ``` **Example: Hybrid Search with Reranking** ```python from langchain.retrievers import EnsembleRetriever from langchain_community.retrievers import BM25Retriever from langchain.schema import Document # Prepare documents docs = [ Document(page_content="RAG系统需要向量检索和重排序"), Document(page_content="混合检索结合了稀疏和密集检索"), # ... more documents ] # 1. Dense retriever (FAISS) dense_retriever = vectorstore.as_retriever(search_kwargs={"k": 5}) # 2. Sparse retriever (BM25) bm25_retriever = BM25Retriever.from_documents(docs) bm25_retriever.k = 5 # 3. Ensemble retriever ensemble_retriever = EnsembleRetriever( retrievers=[dense_retriever, bm25_retriever], weights=[0.5, 0.5] ) # 4. Retrieve with hybrid search results = ensemble_retriever.get_relevant_documents("RAG混合检索") for doc in results: print(f"- {doc.page_content}") ``` ### 5. Tool Calling & MCP Protocol **Example: Function Calling with Tools** ```python from langchain.tools import tool from langchain_openai import ChatOpenAI from langchain.agents import create_openai_tools_agent, AgentExecutor