这次我们来看一个面向2026年的AI应用开发实战教程，核心是整合LangChain、LangGraph、LLaMA-Factory、RAG和MCP这五大技术栈，构建一个从模型微调到智能体（Agent）落地的完整开发链路。如果你关心如何将前沿的开源大模型技术栈串联起来，实现一个具备长期记忆、工具调用和知识检索能力的本地AI应用，这篇文章可以直接收藏。

这个教程的重点不是单一工具的概念，而是如何将它们组合成一个可运行的、功能连贯的系统。它涵盖了从模型选择与微调（LLaMA-Factory）、知识库构建（RAG）、智能体工作流编排（LangGraph）、外部工具扩展（MCP）到最终应用集成（LangChain）的全过程。对于希望深入AI应用开发，特别是想构建私有化、定制化AI助理或业务自动化工具的开发者来说，这套组合拳提供了清晰的实践路径。

本文会带你快速梳理这套技术栈的核心价值、部署门槛和关键操作。我们将重点关注：如何利用LLaMA-Factory在消费级显卡上微调模型；如何搭建一个高效的RAG知识库系统；如何使用LangGraph构建具备状态和复杂逻辑的智能体；以及如何通过MCP协议安全地扩展智能体的能力边界。整个过程会围绕一个“本地AI智能体”的构建场景展开，让你看完就能知道从哪里开始动手。

1. 核心能力速览

能力项 说明
技术栈构成 LangChain (应用框架) + LangGraph (工作流/智能体) + LLaMA-Factory (模型微调) + RAG (检索增强生成) + MCP (模型上下文协议)
核心目标 构建具备长期记忆、工具调用、知识检索和复杂任务分解能力的本地AI智能体应用。
硬件门槛 模型微调 (LLaMA-Factory) ：建议至少12GB显存（如RTX 3060 12G/4060 Ti 16G）进行QLoRA微调。 推理/RAG ：6-8GB显存可运行7B/8B量级模型，纯CPU推理速度较慢但可行。
启动与部署 各组件独立部署：LLaMA-Factory提供WebUI和API；RAG系统需部署向量数据库；LangGraph/LangChain为Python库；MCP Server需单独运行。
接口能力 LLaMA-Factory提供完善的训练与推理API；LangChain/LangGraph可封装成FastAPI/Flask服务；MCP提供标准化的工具调用接口。
批量任务 LLaMA-Factory支持数据集的批量训练；RAG支持文档的批量入库与索引构建；LangGraph可编排批量的、序列化的智能体任务。
适合场景 开发私有知识库问答机器人、自动化业务流程智能体、具备长期记忆的个人AI助手、集成内部工具的企业级AI应用。

2. 适用场景与使用边界

这套技术栈组合主要面向中高级开发者、AI应用架构师以及有私有化部署需求的技术团队。

它非常适合解决以下问题：

  1. 私有知识问答 ：将公司内部文档、产品手册、代码库构建成RAG知识库，让大模型基于这些私有知识进行精准回答，避免“胡言乱语”。
  2. 复杂任务自动化 ：例如，让智能体根据自然语言指令“检查服务器A的日志，找到最近的错误，总结并发送邮件给运维团队”。这需要分解任务、调用日志查询工具、分析内容、再调用邮件工具。
  3. 个性化AI助手 ：基于个人或组织的对话历史、偏好数据对开源模型进行微调，打造一个更懂你的、可长期对话的专属助手。
  4. 安全可控的工具集成 ：通过MCP协议，以标准、安全的方式让AI智能体调用外部工具（如数据库、API、命令行），避免直接将敏感权限暴露给模型。

它的局限性与使用边界：

  1. 技术复杂度高 ：涉及多个组件，环境配置、联调调试有一定门槛，不适合AI入门新手只想“一键生成”。
  2. 性能依赖硬件 ：微调和高效推理需要较好的GPU支持。纯CPU环境虽可运行，但体验不佳。
  3. 效果取决于数据与调优 ：RAG的检索质量、模型微调的效果、智能体工作流的设计，都严重依赖高质量的数据和细致的工程调优，不是“部署即完美”。
  4. 合规与授权 ：使用开源模型和自建知识库，需确保训练数据、知识库文档的版权和隐私合规。微调后的模型也应遵循原模型的开源协议。

3. 环境准备与前置条件

在开始整合之前，需要确保你的开发环境满足各组件的基本要求。以下是一个推荐的基线配置清单：

操作系统：

  • Ubuntu 20.04/22.04 LTS 或 Windows 10/11 (WSL2 强烈推荐) 或 macOS (仅限CPU/部分GPU推理)。
  • 本文以 Ubuntu/WSL2 环境为主要示例。

Python 环境：

  • Python 3.10 或 3.11。这是当前多数AI框架最兼容的版本。
  • 使用 conda 或 venv 创建独立的虚拟环境是必须的，以避免依赖冲突。 
# 使用 conda 示例
conda create -n ai-agent python=3.10
conda activate ai-agent

GPU 与驱动 (如需GPU加速)：

  • NVIDIA GPU (推荐RTX 3060 12G 或更高)。
  • 安装对应版本的 NVIDIA 驱动和 CUDA Toolkit (如 CUDA 11.8 或 12.1)。可通过 nvidia-smi 命令验证。

核心工具链：

  • Git：用于克隆代码仓库。
  • Docker & Docker Compose (可选但推荐)：用于快速部署向量数据库等中间件。

磁盘空间：

  • 预留至少 50GB 可用空间。用于存放模型文件（一个7B模型约15GB）、向量数据库、训练数据及依赖包。

4. 安装部署与启动方式

各组件需要分别安装和启动。我们遵循从底层（模型）到上层（应用）的顺序。

4.1 LLaMA-Factory：模型微调与推理服务

LLaMA-Factory 是一个功能强大的开源大模型微调框架，支持众多模型（LLaMA, Qwen, Baichuan, ChatGLM等）和高效微调技术（如LoRA, QLoRA）。

1. 克隆项目与安装依赖： 

git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -r requirements.txt

2. 准备模型文件：

  • 从 Hugging Face 或其他源下载你选择的基础模型（如 Qwen2.5-7B-Instruct ），并放置在 LLaMA-Factory/models/ 目录下。

3. 启动 Web UI (训练与推理)： 

# 启动训练WebUI
CUDA_VISIBLE_DEVICES=0 python src/train_web.py
# 启动推理WebUI (也可用于聊天测试)
CUDA_VISIBLE_DEVICES=0 python src/web_demo.py

启动后，默认在浏览器打开 http://localhost:7860 即可访问。通过WebUI可以直观地进行数据集准备、LoRA微调参数配置、启动训练和模型测试。

4. 启动 API 服务： LLaMA-Factory 提供了与 OpenAI API 兼容的接口，方便 LangChain 等框架调用。 

# 启动API服务器，指定你微调好的或下载的模型
CUDA_VISIBLE_DEVICES=0 python src/api_demo.py \
    --model_name_or_path ./models/Qwen2.5-7B-Instruct \
    --template qwen \
    --finetuning_type lora \
    --checkpoint_dir ./saves/qwen2.5-7b-lora

API 服务默认运行在 http://localhost:8000 ，提供 /v1/chat/completions 等端点。

4.2 RAG 知识库：向量数据库与检索服务

RAG 系统通常包含文本加载、分块、向量化、存储和检索几个部分。这里以 Chroma (轻量级向量数据库) 和 LangChain 的文档处理链为例。

1. 安装向量数据库与相关库： 

pip install chromadb langchain langchain-community sentence-transformers
# 选用一个嵌入模型，例如 all-MiniLM-L6-v2

2. 构建知识库的核心脚本示例 ( build_knowledge_base.py )： 

import os
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

# 1. 加载文档 (假设文档在 ./docs 目录)
documents = []
for root, dirs, files in os.walk("./docs"):
    for file in files:
        if file.endswith(('.txt', '.md', '.pdf')): # 可扩展PDF解析器
            path = os.path.join(root, file)
            loader = TextLoader(path, encoding='utf-8')
            documents.extend(loader.load())

# 2. 分割文档
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(documents)

# 3. 创建嵌入模型
embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

# 4. 构建并持久化向量数据库
vector_db = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db" # 向量数据库存储路径
)
vector_db.persist()
print("知识库构建完成！")

3. 启动独立的检索服务 (可选)： 你可以将上述检索功能封装成一个 FastAPI 服务，供智能体调用。 

pip install fastapi uvicorn

然后创建一个 rag_api.py ，提供 /search 接口。

4.3 LangGraph & LangChain：智能体工作流编排

LangGraph 是构建有状态、多步骤智能体的强大框架，而 LangChain 提供了丰富的组件链。

1. 安装： 

pip install langgraph langchain langchain-openai
# 注意：这里使用 langchain-openai 是为了兼容 OpenAI API 格式，实际后端是我们部署的 LLaMA-Factory API。

2. 定义智能体状态与工具： 智能体的核心是“状态”和“节点”。状态是一个字典，记录对话和中间结果；节点是执行具体步骤的函数。 

from typing import TypedDict, Annotated, List
from langgraph.graph import StateGraph, END
import operator

# 1. 定义状态结构
class AgentState(TypedDict):
    question: str
    context: Annotated[List[str], operator.add]  # 检索到的知识片段
    answer: str
    iterations: int

# 2. 定义工具函数 (例如：调用RAG检索)
def retrieve_knowledge(state: AgentState):
    # 这里模拟调用前面构建的RAG检索服务
    # 实际应发送请求到你的 RAG API
    query = state["question"]
    # simulated_retrieval 应替换为真实的检索调用
    retrieved_docs = simulated_retrieval(query, top_k=3)
    return {"context": retrieved_docs}

# 3. 定义LLM调用函数 (连接到LLaMA-Factory API)
def call_llm(state: AgentState):
    from langchain_openai import ChatOpenAI
    # 将LLaMA-Factory API配置为OpenAI兼容端点
    llm = ChatOpenAI(
        base_url="http://localhost:8000/v1", # LLaMA-Factory API地址
        api_key="no-api-key-required", # 如果未设置认证
        model="qwen2.5-7b-instruct"
    )
    prompt = f"""基于以下背景信息回答问题。
    背景：{state['context']}
    问题：{state['question']}
    请给出准确、简洁的答案。"""
    response = llm.invoke(prompt)
    return {"answer": response.content}

# 4. 构建图
graph_builder = StateGraph(AgentState)
graph_builder.add_node("retrieve", retrieve_knowledge)
graph_builder.add_node("generate", call_llm)
graph_builder.set_entry_point("retrieve")
graph_builder.add_edge("retrieve", "generate")
graph_builder.add_edge("generate", END)
agent_graph = graph_builder.compile()

4.4 MCP (Model Context Protocol)：工具扩展协议

MCP 是一种标准化协议，允许AI模型安全地发现和调用外部工具（如搜索引擎、数据库、代码执行器）。你需要运行一个 MCP 服务器来提供这些工具。

1. 安装 MCP SDK： 

pip install mcp

2. 创建一个简单的 MCP 服务器示例 ( mcp_server.py )： 这个服务器提供了一个“获取当前时间”的工具。 

# mcp_server.py
import asyncio
from datetime import datetime
from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions
import mcp.server.stdio
from mcp.types import Tool, TextContent

server = Server("my-tool-server")

@server.list_tools()
async def handle_list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_current_time",
            description="获取当前的系统日期和时间。",
            inputSchema={
                "type": "object",
                "properties": {}
            }
        )
    ]

@server.call_tool()
async def handle_call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "get_current_time":
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        return [TextContent(type="text", text=f"当前时间是：{current_time}")]
    raise ValueError(f"未知工具: {name}")

async def main():
    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            InitializationOptions(
                server_name="my-server",
                server_version="0.1.0",
            ),
            NotificationOptions(),
        )

if __name__ == "__main__":
    asyncio.run(main())

3. 运行 MCP 服务器： 

python mcp_server.py

服务器将通过 stdio 通信。你需要使用支持 MCP 的客户端（如 Claude Desktop，或自己实现的客户端）来连接并使用它提供的工具。在 LangGraph 智能体中，可以通过客户端库调用这些工具。

5. 功能测试与效果验证

整个系统搭建完成后，需要通过关键场景验证其协同工作能力。

5.1 测试1：基础模型推理 (LLaMA-Factory API)

目的 ：验证微调后的模型或基础模型能否通过API正常响应。 操作 ：

  1. 确保 LLaMA-Factory API 服务 ( api_demo.py ) 正在运行。
  2. 使用 curl 或 Python 脚本发送测试请求。 
curl -X POST "http://localhost:8000/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-7b-instruct",
    "messages": [{"role": "user", "content": "你好，请介绍一下你自己。"}],
    "temperature": 0.7
  }'

预期结果 ：收到一个结构化的 JSON 响应，包含模型生成的回复内容。 成功标准 ：HTTP 状态码为 200，且 response.choices[0].message.content 包含连贯的文本。

5.2 测试2：RAG 知识检索

目的 ：验证向量数据库是否能根据问题检索到相关的文档片段。 操作 ：

  1. 运行 build_knowledge_base.py 构建知识库。
  2. 编写一个简单的检索测试脚本。 
# test_retrieval.py
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
vector_db = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

query = "LangGraph 是什么？它和 LangChain 有什么区别？"
docs = vector_db.similarity_search(query, k=2)
for i, doc in enumerate(docs):
    print(f"片段 {i+1}: {doc.page_content[:200]}...\n")

预期结果 ：打印出与问题最相关的2个文本片段。 成功标准 ：返回的片段内容确实与 LangGraph 和 LangChain 相关。

5.3 测试3：智能体工作流执行 (LangGraph)

目的 ：验证智能体能否按预设流程（先检索，后生成）工作。 操作 ：

  1. 确保 LLaMA-Factory API 和 RAG 检索功能可用（可以先用模拟函数）。
  2. 运行之前定义的 agent_graph 。 
# test_agent.py
from langgraph.graph import StateGraph, END
# ... (包含之前定义的 AgentState, retrieve_knowledge, call_llm, graph_builder 等代码)

def simulated_retrieval(query, top_k=3):
    # 模拟检索，实际应连接真实向量库
    return [f"模拟检索到的关于'{query}'的文档内容片段 {i+1}。" for i in range(top_k)]

if __name__ == "__main__":
    # 初始化状态
    initial_state = AgentState(question="什么是RAG？", context=[], answer="", iterations=0)
    # 执行图
    final_state = agent_graph.invoke(initial_state)
    print("问题：", final_state["question"])
    print("检索到的上下文：", final_state["context"])
    print("智能体生成的答案：", final_state["answer"])

预期结果 ：控制台输出显示，智能体先执行了“retrieve”节点（获得上下文），再执行了“generate”节点（生成答案）。 成功标准 ： final_state 中包含了 context 和 answer 字段，且答案是基于（模拟的）上下文生成的。

5.4 测试4：工具调用集成 (MCP)

目的 ：验证智能体能否通过 MCP 调用外部工具。 操作 ：

  1. 运行 mcp_server.py 。
  2. 在智能体工作流中增加一个调用 get_current_time 工具的节点。
  3. 修改状态图，让智能体在需要时调用该工具。 成功标准 ：智能体的最终输出中包含了从 MCP 服务器获取的当前时间信息。

6. 接口 API 与批量任务

6.1 统一应用层 API

为了前端或其他服务调用，我们需要将整个智能体系统封装成一个统一的 HTTP API。可以使用 FastAPI 来实现。 

# app/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from .agent_graph import agent_graph  # 导入之前编译好的智能体图

app = FastAPI(title="AI Agent API")

class QueryRequest(BaseModel):
    question: str

class QueryResponse(BaseModel):
    answer: str
    context: list[str]
    status: str

@app.post("/query", response_model=QueryResponse)
async def query_agent(request: QueryRequest):
    try:
        initial_state = {"question": request.question, "context": [], "answer": "", "iterations": 0}
        result = agent_graph.invoke(initial_state)
        return QueryResponse(
            answer=result["answer"],
            context=result["context"],
            status="success"
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)

6.2 批量任务处理

对于需要处理大量问题的场景（如批量分析客服记录），可以构建一个简单的任务队列。 

# batch_processor.py
import asyncio
import aiohttp
import pandas as pd
from tqdm import tqdm

async def process_one_question(session, url, question):
    async with session.post(url, json={"question": question}) as resp:
        return await resp.json()

async def batch_process(questions: list, api_url="http://localhost:8080/query", concurrency=5):
    """
    批量处理问题列表
    :param questions: 问题列表
    :param api_url: 智能体API地址
    :param concurrency: 并发数
    """
    connector = aiohttp.TCPConnector(limit=concurrency)
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = [process_one_question(session, api_url, q) for q in questions]
        results = []
        for f in tqdm(asyncio.as_completed(tasks), total=len(tasks)):
            results.append(await f)
        return results

# 使用示例
if __name__ == "__main__":
    df = pd.read_csv("questions.csv") # 假设有一个CSV文件
    questions = df["question"].tolist()[:100] # 处理前100个
    loop = asyncio.get_event_loop()
    answers = loop.run_until_complete(batch_process(questions))
    # 将结果保存
    output_df = pd.DataFrame(answers)
    output_df.to_csv("answers.csv", index=False)

7. 资源占用与性能观察

1. 显存占用分析：

  • LLaMA-Factory 微调 (QLoRA) ：以 7B 模型为例， batch_size=1 时，显存占用通常在 12GB - 16GB 之间，具体取决于序列长度和优化器。使用 --quantization_bit 4 可进一步降低。
  • LLaMA-Factory 推理 ：加载 7B 的 INT4 量化模型，显存占用约为 5-6GB。加载 FP16 模型，显存占用约为 14GB。
  • RAG 嵌入模型 ： all-MiniLM-L6-v2 等轻量级模型加载到 GPU 显存约 1-2GB，CPU 推理也可接受。
  • LangGraph/LangChain ：作为控制框架，本身几乎不占用显存，主要内存消耗在 Python 运行时和中间数据。

观察命令： 

# 在Linux/WSL下，实时查看GPU使用情况
watch -n 1 nvidia-smi
# 查看进程内存占用
htop

2. 响应延迟：

  • 首次加载模型 ：耗时较长，可能数十秒到数分钟。
  • 单次推理 (7B模型) ：在 RTX 4060 Ti 16G 上，生成 100 个 token 大约需要 1-3 秒，取决于序列长度。
  • RAG 检索 ：从千万级向量的数据库中检索 top_k 结果，通常在 100 毫秒以内。
  • 智能体单轮循环 ： 检索 -> LLM生成 的完整周期，在本地环境下可能在 2-10 秒，受网络延迟（如果API非本地）、检索复杂度和生成长度影响。

性能优化建议：

  • 模型量化 ：优先使用 GPTQ、AWQ 或 GGUF 格式的量化模型进行推理，大幅降低显存和提升速度。
  • 缓存嵌入 ：对不变的文档库，预计算并缓存所有文档块的嵌入向量，避免每次检索重复计算。
  • 异步处理 ：对于 API 服务，使用 async/await 和 uvicorn 的异步 workers 提高并发吞吐量。
  • 批处理 ：在批量任务中，适当合并请求或使用模型的批处理能力。

8. 常见问题与排查方法

问题现象 可能原因 排查方式 解决方案
LLaMA-Factory WebUI 无法启动 端口被占用；依赖未安装完全；CUDA环境问题。 1. 检查端口 7860 或 8000 。
2. 查看命令行错误日志。
3. 运行 python -c "import torch; print(torch.cuda.is_available())" 。 		1. 更换端口 --port 7861 。
2. 重新安装依赖 pip install -r requirements.txt 。
3. 配置正确的CUDA环境。
模型加载失败或显存不足 模型路径错误；模型文件损坏；显存确实不足。 1. 确认 --model_name_or_path 路径正确且包含所有必要文件。
2. 使用 nvidia-smi 观察显存占用。
3. 尝试加载更小的模型或量化版本。 		1. 重新下载模型文件。
2. 使用量化模型 (如 Qwen2.5-7B-Instruct-GPTQ-Int4 )。
3. 增加系统交换空间或使用CPU卸载。
RAG 检索结果不相关 文档分块策略不当；嵌入模型不匹配；检索参数 top_k 不合理。 1. 检查分块大小和重叠是否适合你的文档类型。
2. 确认构建和检索时使用的是同一个嵌入模型。
3. 尝试调整 similarity_search 的 k 值或使用 similarity_search_with_score 查看分数。 		1. 调整 chunk_size 和 chunk_overlap 。
2. 尝试更强的嵌入模型，如 bge-large-zh-v1.5 。
3. 引入元数据过滤或重排序 (re-ranking) 技术。
LangGraph 智能体状态不更新 节点函数没有正确修改状态；边 (Edge) 连接错误。 1. 在每个节点函数内打印 state 。
2. 检查 add_edge 和 set_entry_point 的逻辑。
3. 使用 graph_builder.compile().get_graph().draw_mermaid() 可视化图结构 (需安装 pygraphviz )。 		1. 确保节点函数返回一个字典，其键对应状态中需要更新的字段。
2. 仔细检查图的连接逻辑，确保没有形成死循环或断点。
MCP 服务器连接失败 客户端与服务器通信协议不一致；服务器未正常启动。 1. 检查 MCP 服务器进程是否在运行。
2. 查看服务器日志是否有错误。
3. 确认客户端使用的传输方式 (stdio, http) 与服务器匹配。 		1. 确保使用正确版本的 MCP 客户端库。
2. 参考官方 MCP 示例编写最简单的客户端进行连通性测试。
API 调用超时 后端服务处理时间过长；网络问题；并发过高。 1. 直接在后端服务命令行查看单次请求处理时间。
2. 使用 curl 或 Postman 测试，排除前端代码问题。
3. 检查服务器资源 (CPU/内存/GPU) 是否饱和。 		1. 优化模型推理参数 (如减少 max_new_tokens )。
2. 为 API 服务设置合理的超时时间，并实现异步处理。
3. 对服务进行水平扩展。

9. 最佳实践与使用建议

  1. 循序渐进，分步验证 ：不要试图一次性集成所有组件。先确保 LLaMA-Factory API 能跑通，再构建 RAG，然后集成 LangGraph，最后接入 MCP。每步都做独立测试。
  2. 版本锁定与环境隔离 ：使用 requirements.txt 或 poetry 严格锁定主要库的版本（如 torch , transformers , langchain ），避免因版本升级导致的不兼容。
  3. 配置外部化 ：将模型路径、API地址、数据库连接等配置项写入 config.yaml 或 .env 文件，便于不同环境（开发、测试、生产）切换。
  4. 日志与监控 ：在关键节点（模型调用、工具执行、错误捕获）添加详细的日志记录。考虑集成像 Prometheus 和 Grafana 来监控 API 延迟、错误率和资源使用情况。
  5. 数据质量是生命线 ：
    • RAG ：清洗你的文档，设计合理的分块策略。好的分块比强大的模型更重要。
    • 微调 ：精心准备高质量、多样化的指令微调数据。数据质量直接决定模型性能上限。
  6. 安全与合规 ：
    • API 安全 ：对向外暴露的 API 接口（如 /query ）实施认证、限流和输入过滤。
    • 工具权限 ：通过 MCP 暴露给智能体的工具，必须遵循最小权限原则。例如，数据库工具应只有查询权限，而非写权限。
    • 内容审核 ：在智能体输出最终答案前，可加入一层内容安全过滤，防止生成有害或不适当内容。
  7. 备份与回滚 ：对微调好的模型 checkpoint、构建好的向量数据库进行定期备份。在升级任何组件前，确保有快速回滚的方案。

这套以 LangChain + LangGraph + LLaMA-Factory + RAG + MCP 为核心的技术栈，为构建下一代 AI 应用提供了坚实、灵活且可扩展的基石。它最大的价值在于将模型能力、知识记忆、逻辑编排和工具使用解耦，让你可以像搭积木一样设计和迭代你的智能体。最值得优先尝试的，是先用 LLaMA-Factory 在本地跑通一个模型的微调与 API 服务，再结合 LangChain 搭建一个最简单的文档问答流程。这两个环节打通后，你会对整个系统的数据流和控制流有直观感受，后续引入 LangGraph 的状态管理和 MCP 的工具扩展便会水到渠成。过程中最容易踩的坑通常是环境配置和版本冲突，因此严格按照文档操作并使用虚拟环境是节省时间的关键。

# LLaMA-Factory
Logo
天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

deck.gl TripsLayer 出租车轨迹动画示例实战：从示例运行到着色器原理

TripsLayer 是 deck.gl 中用于渲染**随时间流动的轨迹动画**（如出租车行程、物流路径、迁徙路线）的核心图层。本文以仓库中的最小独立示例 [examples/website/trips](https://link.gitcode.com/i/1442af8f442f4cff39ff546e050fceb5) 为骨架，带你完成从安装依赖、启动应用、理解曼哈顿出租车数据格式，到深入

avatar 天工造物局

Foundry Anvil 中 eth_simulateV1 的 Blob 交易与 Blob Gas 字段规范化：原理、实现与测试验证

本篇技术指南以 [anvil-simulate-blob-transactions.md](https://link.gitcode.com/i/3d2ebe227262de169335eb290af80da8) 这条 changelog 条目为起点，深入剖析 Foundry Anvil 对 `eth_simulateV1` RPC 返回结果中 blob（EIP-4844）交易与 blob gas

avatar 天工造物局

LMCache CLI 实战：用 `lmcache kvcache clear` 管理运行中服务的 KV Cache 状态

本文是一份针对 LMCache 官方 CLI 命令 `lmcache kvcache` 的完整技术指南。该命令用于在**运行中的 LMCache 服务（MP HTTP server）**上管理 KV cache 状态，当前提供 `clear` 子命令，用于清空 L1（CPU 内存）层中缓存的全部 KV 数据。读完本文，你将掌握该命令的完整参数体系、退出码语义、终端/JSON/静默三种输出模式，并能

avatar 天工造物局