🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

在实际 AI 大模型应用开发中，很多开发者会遇到一个典型困境：网上教程要么只讲理论，要么只给一个简单的 API 调用示例，而当你真正想构建一个私有化、可定制、能处理企业知识的智能应用时，却找不到一条从零到一的完整路径。这个路径至少应该包含如何将大模型部署到自己的服务器、如何让模型理解你的私有文档、如何根据特定任务对模型进行微调，以及如何用一个高效的工具将这些能力串联成一个可用的应用。

本文将以一个工程实践者的视角，带你走通这条完整链路。我们将聚焦于四个核心环节：大模型的本地部署、RAG 知识库的构建、模型微调实战，以及使用 Dify 进行应用编排。这不是一个概念介绍，而是一个手把手的操作指南，每一步都会包含具体的环境准备、命令执行、配置修改和结果验证。无论你是想为团队搭建一个内部问答助手，还是希望深入理解大模型落地的关键技术，这篇文章都将提供一套可复现的实践方案。

1. 理解核心概念：本地部署、RAG、微调与 Dify 的关系

在开始动手之前，我们需要先厘清这几个关键概念各自解决什么问题，以及它们如何协同工作。这能帮助你在后续步骤中，清楚地知道每一步的目标是什么。

1.1 大模型本地部署：获得自主控制权

本地部署大模型，意味着将模型文件下载到你的服务器或本地计算机上，并运行一个推理服务。这样做的主要目的不是为了追求比云端 API 更好的性能（通常相反），而是为了数据安全、网络隔离和成本可控。当你的应用涉及敏感数据，或者需要 7x24 小时稳定运行而不受外部 API 调用限制和费率变化影响时，本地部署是必然选择。常见的本地部署方案包括使用Ollama、vLLM、Text Generation Inference等工具来托管如Llama、Qwen、ChatGLM等开源模型。

1.2 RAG 知识库：让模型“读懂”你的文档

大模型本身是在海量公开数据上训练的，它并不知道你公司内部的规章制度、产品手册或项目文档。Retrieval-Augmented Generation 技术解决了这个问题。其核心思想是：当用户提问时，先从你的私有文档库中检索出相关的文档片段，然后将这些片段和问题一起交给大模型，让它基于这些“参考资料”生成答案。这样，答案的准确性和针对性会大幅提升，同时避免了直接微调模型所需的高昂成本和数据需求。一个典型的 RAG 系统包含文档加载、文本分割、向量化、向量数据库存储和检索等步骤。

1.3 模型微调：让模型“学会”你的任务

如果说 RAG 是给模型“开卷考试”，那么微调就是让模型“针对性复习”。通过在你的特定任务数据（例如客服问答对、代码评审记录、特定风格文本）上继续训练模型，可以显著提升模型在该任务上的表现。微调分为全参数微调和高效微调（如 LoRA）。全参数微调效果好但资源消耗巨大；LoRA 等方法通过只训练少量新增参数来逼近全参数微调的效果，是目前个人开发者和小团队的主流选择。LLaMA-Factory等工具极大地简化了微调流程。

1.4 Dify：低代码的应用编排平台

Dify 是一个开源的 AI 应用开发平台，它像是一个“胶水”，将前面提到的能力可视化地组装起来。你可以在 Dify 中配置你本地部署的模型作为推理后端，连接你搭建的向量数据库作为知识库，并通过图形化界面设计对话流程、编排工具调用（Function Calling）等。它降低了从模型能力到最终应用之间的开发门槛，让你能更专注于业务逻辑而非底层工程。

这四个环节的关系可以这样理解：本地部署提供了模型算力基础，RAG 和微调是两种增强模型特定能力的核心手段，而 Dify 则是将所有这些能力产品化、服务化的高效工具链。

2. 环境准备与基础工具选型

开始实践前，需要准备好开发环境并选择合适的技术栈。以下配置是一个兼顾学习与生产实践的起点。

2.1 硬件与操作系统要求

本地部署和微调大模型对硬件有一定要求，主要取决于模型规模。

对于初学者，如果本地硬件不足，可以考虑租用云服务器（如 AWS EC2g5.xlarge、Google Clouda2-highgpu-1g或国内云厂商的 GPU 实例），按需使用以降低成本。

2.2 核心工具安装与配置

我们将使用以下工具链，请确保在开始前完成安装。

1. 安装 Python 和 CondaPython 是大多数 AI 工具的基础。使用 Conda 管理独立的 Python 环境可以避免包冲突。

# 以 Ubuntu 为例，安装 Miniconda wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh bash Miniconda3-latest-Linux-x86_64.sh # 按照提示完成安装，然后重启终端或运行 `source ~/.bashrc` # 创建一个名为 `ai-app` 的 Python 3.10 环境 conda create -n ai-app python=3.10 -y conda activate ai-app

2. 安装 CUDA 和 cuDNN（仅限 NVIDIA GPU）这是 GPU 加速的基础。请根据你的显卡驱动版本，在 NVIDIA 官网选择匹配的 CUDA Toolkit 版本（如 12.1）进行安装。安装后，验证 CUDA 是否可用：

nvidia-smi # 查看 GPU 状态 nvcc --version # 查看 CUDA 编译器版本

3. 安装 Docker 和 Docker Compose很多工具（如 Dify、某些向量数据库）推荐使用 Docker 部署，这能极大简化环境依赖问题。

# Ubuntu 安装 Docker sudo apt-get update sudo apt-get install docker.io docker-compose -y # 将当前用户加入 docker 组，避免每次使用 sudo sudo usermod -aG docker $USER newgrp docker # 刷新组权限，或重新登录终端 # 验证安装 docker --version docker-compose --version

3. 第一步：大模型本地部署实战（以 Ollama 为例）

Ollama 是目前最易用的本地大模型运行框架之一，它简化了模型下载、加载和提供 API 的整个过程。

3.1 安装与运行 Ollama

访问 Ollama 官网下载对应操作系统的安装包，或使用命令行安装：

# Linux/macOS 一键安装脚本 curl -fsSL https://ollama.com/install.sh | sh # Windows 用户请直接下载安装包

安装完成后，启动 Ollama 服务。它会以后台服务形式运行。

# 启动 Ollama 服务（通常安装后已自动启动） ollama serve &

3.2 拉取并运行一个开源模型

Ollama 托管了众多优化后的开源模型。我们从一个小尺寸模型开始，验证部署是否成功。

# 拉取 Llama 3 的 8B 参数版本（约 4.7GB） ollama pull llama3:8b # 拉取成功后，以交互模式运行模型 ollama run llama3:8b

运行后，你会进入一个对话界面，可以直接输入英文问题测试。输入/bye退出。

关键解释：ollama pull命令会从 Ollama 服务器下载模型文件。llama3:8b是模型标签，其中8b指 80 亿参数。对于中文场景，你可能更想尝试qwen2:7b或llama3-chinese:8b等模型，用法相同。

3.3 验证模型 API 服务

Ollama 默认在11434端口提供了兼容 OpenAI API 格式的接口。我们可以用curl命令测试。

# 测试生成接口 curl http://localhost:11434/api/generate -d '{ "model": "llama3:8b", "prompt": "请用中文介绍一下你自己。", "stream": false }'

如果返回一个包含response字段的 JSON，里面有大模型生成的自我介绍，说明本地模型服务部署成功。

生产环境注意：默认配置下，Ollama 的 API 没有鉴权且绑定在0.0.0.0。在生产环境，你需要通过防火墙限制访问来源，或者使用 Nginx 配置反向代理并添加 API 密钥认证。

3.4 常见部署问题排查

4. 第二步：构建私有 RAG 知识库

本地模型已经就绪，现在我们要让它“读懂”我们的私有文档。这里我们使用LangChain作为框架，Chroma作为向量数据库。

4.1 安装必要的 Python 库

在你的ai-appConda 环境中，安装以下依赖：

pip install langchain langchain-community langchain-chroma pypdf python-dotenv sentence-transformers

• langchain: 编排框架。
• langchain-community: 社区集成的各种工具和组件。
• langchain-chroma: Chroma 向量数据库的集成。
• pypdf: 用于解析 PDF 文档。
• sentence-transformers: 用于生成文本向量的嵌入模型。

4.2 文档处理与向量化流程

RAG 的核心流程是：加载文档 -> 分割文本 -> 文本转向量 -> 存入向量数据库。我们创建一个 Python 脚本build_knowledge_base.py来实现。

# build_knowledge_base.py import os from langchain_community.document_loaders import PyPDFLoader, TextLoader from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_community.embeddings import HuggingFaceEmbeddings from langchain_chroma import Chroma # 1. 配置嵌入模型（使用本地模型，无需API密钥） # 这里选用一个轻量且效果不错的中文嵌入模型 embedding_model = HuggingFaceEmbeddings( model_name="BAAI/bge-small-zh-v1.5", # 中文小模型 model_kwargs={'device': 'cpu'}, # 如果显存够，可改为 `cuda` encode_kwargs={'normalize_embeddings': True} ) # 2. 指定你的文档目录 doc_dir = "./my_docs" documents = [] # 3. 加载文档（支持PDF和TXT） for filename in os.listdir(doc_dir): file_path = os.path.join(doc_dir, filename) if filename.endswith(".pdf"): loader = PyPDFLoader(file_path) documents.extend(loader.load()) elif filename.endswith(".txt"): loader = TextLoader(file_path, encoding='utf-8') documents.extend(loader.load()) else: print(f"跳过不支持的文件格式: {filename}") print(f"共加载 {len(documents)} 个文档片段。") # 4. 分割文本 # 大模型有上下文长度限制，需要把长文档切成小块。 text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, # 每个块约500字符 chunk_overlap=50, # 块之间重叠50字符，保持语义连贯 separators=["\n\n", "\n", "。", "！", "？", "；", "，", " ", ""] ) split_docs = text_splitter.split_documents(documents) print(f"分割后得到 {len(split_docs)} 个文本块。") # 5. 创建向量数据库并持久化存储 # 将文本块转换为向量，并存入 Chroma 数据库 vector_db = Chroma.from_documents( documents=split_docs, embedding=embedding_model, persist_directory="./chroma_db" # 向量数据库存储路径 ) vector_db.persist() # 持久化到磁盘 print("知识库构建完成，已保存至 ./chroma_db")

关键参数解释：

• chunk_size: 文本块大小。太小会丢失上下文，太大会超出模型处理能力。500-1000 是常见范围。
• chunk_overlap: 重叠字符数。防止一个句子被切到两个块中间导致语义断裂。
• embedding_model: 将文本转换为数学向量（嵌入）的模型。向量的相似度代表了文本语义的相似度。我们选用了开源的BAAI/bge-small-zh-v1.5，它首次运行时会从 Hugging Face 下载模型文件。

4.3 实现检索与问答

知识库建好后，我们编写另一个脚本ask_rag.py来实现问答。

# ask_rag.py from langchain_chroma import Chroma from langchain_community.embeddings import HuggingFaceEmbeddings from langchain.prompts import PromptTemplate from langchain.chains import RetrievalQA import sys # 1. 加载相同的嵌入模型和向量数据库 embedding_model = HuggingFaceEmbeddings( model_name="BAAI/bge-small-zh-v1.5", model_kwargs={'device': 'cpu'}, encode_kwargs={'normalize_embeddings': True} ) vector_db = Chroma( persist_directory="./chroma_db", embedding_function=embedding_model ) # 2. 定义一个提示词模板，指导模型如何利用上下文 prompt_template = """请根据以下上下文信息回答问题。如果上下文信息中没有相关答案，请直接说“根据已知信息无法回答该问题”，不要编造答案。 上下文： {context} 问题：{question} 答案：""" PROMPT = PromptTemplate( template=prompt_template, input_variables=["context", "question"] ) # 3. 构建检索问答链 qa_chain = RetrievalQA.from_chain_type( llm=None, # 这里先不连接大模型，只测试检索 chain_type="stuff", # 将检索到的所有上下文“塞”进提示词 retriever=vector_db.as_retriever(search_kwargs={"k": 3}), # 检索最相关的3个片段 chain_type_kwargs={"prompt": PROMPT}, return_source_documents=True # 返回来源文档，便于调试 ) # 4. 提问并获取答案（这里只演示检索部分） if __name__ == "__main__": question = sys.argv[1] if len(sys.argv) > 1 else "公司的年假政策是怎样的？" result = qa_chain.invoke({"query": question}) print(f"问题：{question}") print(f"检索到的相关文档：") for i, doc in enumerate(result['source_documents']): print(f"[片段{i+1}] {doc.page_content[:200]}...") # 打印前200字符 # 注意：此时还没有调用大模型生成最终答案，下一步会结合。

运行python ask_rag.py “你的问题”，你会看到系统从向量数据库中检索出的最相关的文本片段。这证明了 RAG 的“检索”部分已经正常工作。

4.4 连接本地模型完成完整 RAG

现在，我们将检索到的上下文和问题，一起发送给我们在第一步部署的本地 Ollama 模型来生成最终答案。修改ask_rag.py，集成 Ollama。

首先，安装 LangChain 的 Ollama 集成包：

pip install langchain-ollama

然后，更新ask_rag.py：

# ask_rag.py (更新版) from langchain_ollama import OllamaLLM # 新增 from langchain_chroma import Chroma from langchain_community.embeddings import HuggingFaceEmbeddings from langchain.prompts import PromptTemplate from langchain.chains import RetrievalQA import sys # 1. 加载嵌入模型和向量数据库（同上） embedding_model = HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh-v1.5", model_kwargs={'device': 'cpu'}, encode_kwargs={'normalize_embeddings': True}) vector_db = Chroma(persist_directory="./chroma_db", embedding_function=embedding_model) # 2. 连接本地 Ollama 模型服务 llm = OllamaLLM(model="llama3:8b", base_url="http://localhost:11434") # 指定模型和地址 # 3. 提示词模板（同上） prompt_template = """请根据以下上下文信息回答问题。如果上下文信息中没有相关答案，请直接说“根据已知信息无法回答该问题”，不要编造答案。 上下文： {context} 问题：{question} 答案：""" PROMPT = PromptTemplate(template=prompt_template, input_variables=["context", "question"]) # 4. 构建完整的 RAG 链 qa_chain = RetrievalQA.from_chain_type( llm=llm, # 传入本地模型 chain_type="stuff", retriever=vector_db.as_retriever(search_kwargs={"k": 3}), chain_type_kwargs={"prompt": PROMPT}, return_source_documents=False ) if __name__ == "__main__": question = sys.argv[1] if len(sys.argv) > 1 else "公司的年假政策是怎样的？" answer = qa_chain.invoke({"query": question}) print(f"问题：{question}") print(f"答案：{answer['result']}")

运行这个脚本，你将得到一个基于私有知识库、由本地大模型生成的答案。至此，一个完整的本地化 RAG 系统就搭建成功了。

5. 第三步：使用 LLaMA-Factory 对模型进行微调

当 RAG 提供的“外部知识”不足以解决某些复杂任务（如特定格式生成、风格模仿、复杂推理）时，就需要对模型本身进行微调。我们使用LLaMA-Factory这个高效微调框架，它支持 LoRA、QLoRA 等多种高效微调方法。

5.1 拉取 LLaMA-Factory 并安装依赖

# 克隆仓库 git clone https://github.com/hiyouga/LLaMA-Factory.git cd LLaMA-Factory # 创建并激活虚拟环境（可选，也可用之前的conda环境） conda create -n llama-factory python=3.10 -y conda activate llama-factory # 安装依赖 pip install -r requirements.txt

5.2 准备微调数据集

微调需要准备一个符合特定格式的数据集。通常是一个 JSON 文件，每条数据包含一个指令（instruction）、输入（input）和输出（output）。我们创建一个简单的示例数据集demo_data.json：

[ { "instruction": "将以下中文翻译成英文", "input": "今天天气真好。", "output": "The weather is really nice today." }, { "instruction": "将以下中文翻译成英文", "input": "人工智能正在改变世界。", "output": "Artificial intelligence is changing the world." }, { "instruction": "总结以下段落的大意", "input": "LangChain是一个用于开发由语言模型驱动的应用程序的框架。它使应用程序具备上下文感知能力，并能进行推理。", "output": "LangChain是一个框架，用于构建基于语言模型的、具有上下文感知和推理能力的应用程序。" } ]

在实际项目中，你需要准备成百上千条高质量的数据。将数据集文件放在LLaMA-Factory/data目录下。

5.3 配置并启动 LoRA 微调

LLaMA-Factory 提供了 Web UI 和命令行两种方式。这里使用更直观的 Web UI。

# 启动 Web UI CUDA_VISIBLE_DEVICES=0 python src/train_web.py

在浏览器中打开http://localhost:7860。

在 Web UI 中，按以下步骤操作：

1. 模型选择：在“模型名称”中，输入你本地已有的模型路径，或 Hugging Face 上的模型 ID（如meta-llama/Llama-3-8B）。如果使用本地 Ollama 模型，需要找到其实际路径（通常在~/.ollama/models/下）。
2. 训练方法：选择LoRA。
3. 数据集：点击“数据集”右边的“i”图标，配置数据集。在弹出框中，输入数据集名称（如my_dataset），选择JSON格式，并指定文件路径（如demo_data.json）。
4. 模板：根据基础模型选择对应的对话模板，如Llama-3。
5. 训练参数：
   • 学习率：5e-5（这是一个常见的起点）。
   • 最大序列长度：512（根据你的数据集和显存调整）。
   • 训练轮数：3.0。
   • 批处理大小：1（如果显存小，设为1）。
6. 输出目录：设置一个目录来保存微调后的模型（如./output）。
7. 点击“开始训练”。

训练开始后，你可以在终端看到损失值下降的日志。训练完成后，会在输出目录生成适配器权重文件（如adapter_model.bin）。

5.4 加载与使用微调后的模型

训练完成后，你可以将微调后的模型（原始模型 + LoRA 适配器）合并导出，或直接加载适配器进行推理。

方法一：在 LLaMA-Factory Web UI 中测试在“推理”标签页，选择你训练时使用的基座模型，并在“适配器路径”中选择你的输出目录（如./output）。然后在聊天框输入指令，模型应该会根据你微调的数据进行回答。

方法二：使用 Ollama 加载（需合并模型）首先，你需要将 LoRA 权重与基座模型合并成一个完整的模型文件。LLaMA-Factory 提供了导出脚本：

python src/export_model.py \ --model_name_or_path /path/to/base_model \ # 基座模型路径 --adapter_name_or_path ./output \ # 你的LoRA权重路径 --template llama3 \ --finetuning_type lora \ --export_dir ./merged_model \ # 合并后模型输出路径 --export_size 2 \ # 量化位数，2表示4-bit --export_legacy_format false

合并后，你可以使用ollama create命令基于这个合并后的模型创建一个新的 Ollama 模型标签，然后像之前一样运行和调用。

5.5 微调过程中的常见问题

6. 第四步：使用 Dify 编排 AI 应用

Dify 可以将我们前面搭建的模型服务、知识库能力，通过可视化界面组装成一个完整的 AI 应用，并提供 API 和用户界面。

6.1 使用 Docker Compose 部署 Dify

这是最推荐的部署方式，能一键解决所有依赖。

# 创建一个工作目录并进入 mkdir dify-deploy && cd dify-deploy # 下载 Docker Compose 配置文件 curl -o docker-compose.yml https://raw.githubusercontent.com/langgenius/dify/main/docker/docker-compose.yaml # 启动所有服务（包括数据库、Redis、Web服务等） docker-compose up -d

等待几分钟，所有容器启动成功后，在浏览器访问http://localhost:3000。首次访问需要创建管理员账户。

6.2 在 Dify 中配置本地模型

1. 登录Dify 控制台。
2. 进入“模型供应商” -> “模型”页面。
3. 点击“添加模型”。
4. 在“模型类型”中选择“OpenAI 兼容”。
5. 填写配置：
   • 模型名称：自定义，如Local-Llama3。
   • 模型类型：选择“文本生成”。
   • 模型 ID：填写llama3:8b（与 Ollama 中的模型标签一致）。
   • API 密钥：留空（因为 Ollama 默认无鉴权）。
   • API 基础 URL：填写http://host.docker.internal:11434/v1。这是关键，host.docker.internal是 Docker 容器访问宿主机服务的特殊域名。
6. 点击“保存”。Dify 会测试连接，成功即可。

6.3 在 Dify 中配置 RAG 知识库

1. 进入“知识库”页面，点击“创建知识库”。
2. 输入知识库名称，如公司内部文档。
3. 在“嵌入模型”处，选择“本地”。由于 Dify 容器内没有我们之前下载的BAAI/bge-small-zh-v1.5模型，我们需要提供一个兼容 OpenAI Embeddings API 的本地服务。一个简单的方法是使用text-embedding模型（需单独部署）。对于学习测试，可以先跳过此步，或使用 Dify 自带的云模型（会产生少量费用）。
4. 创建后，进入知识库，点击“上传文件”，将你的 PDF 或 TXT 文档上传。Dify 会自动完成分割、向量化和存储。

6.4 构建一个对话型应用

1. 进入“应用”页面，点击“创建新应用”，选择“对话型应用”。
2. 配置提示词：在“提示词编排”区域，你可以像写模板一样设计系统提示词。例如：

   你是一个专业的公司内部助手，请根据用户的问题和提供的上下文信息进行回答。 上下文：{{#context#}} 问题：{{#query#}}

   {{#context#}}和{{#query#}}是变量，Dify 会在运行时替换。
3. 连接上下文：在“上下文”区域，开启“知识库”开关，并选择你刚才创建的公司内部文档知识库。这样，用户的问题就会自动触发知识库检索，并将结果填入{{#context#}}变量。
4. 选择模型：在“模型”区域，选择你刚才配置的Local-Llama3。
5. 点击右上角“发布”，即可获得一个可访问的 Web 应用链接和 API 接口。

通过 Dify，你无需编写前后端代码，就拥有了一个具备 RAG 能力的 AI 对话应用。你还可以继续在工作流中编排更复杂的逻辑，如图表生成、代码执行等。

7. 生产环境部署与优化建议

学习环境跑通只是第一步，要让应用稳定服务，还需要考虑以下方面。

7.1 安全性加固

1. API 鉴权：为 Ollama 和 Dify 的 API 添加密钥认证。Ollama 可通过设置环境变量OLLAMA_API_KEY或使用反向代理（如 Nginx）添加 Basic Auth。Dify 在创建 API 密钥时本身就具备鉴权能力。
2. 网络隔离：将模型服务、向量数据库、应用服务部署在内网，通过网关对外暴露。禁止将无鉴权的服务直接暴露在公网。
3. 输入输出过滤：在 Dify 提示词中或应用层，对用户输入进行敏感词过滤和长度限制，防止提示词注入攻击。

7.2 性能与稳定性

1. 模型服务：对于生产环境，Ollama 可能不是最高性能的选择。可以考虑vLLM或TGI作为推理后端，它们支持动态批处理、持续批处理等优化，能显著提高吞吐量。
2. 向量数据库：Chroma 适合轻量级场景。生产环境建议使用Qdrant、Weaviate或Milvus，它们支持分布式、持久化和更丰富的检索功能。
3. 缓存：对频繁的、相同的查询结果进行缓存（例如使用 Redis），可以大幅降低模型调用和检索开销。
4. 监控与日志：为 Ollama、Dify 和应用服务配置详细的日志记录。监控 GPU 使用率、显存占用、API 响应时间和错误率。

7.3 知识库维护

1. 文档更新：建立文档更新流程。当源文件更新后，需要重新触发向量化流程。Dify 知识库支持手动更新索引，也可以调用其 API 实现自动化。
2. 检索优化：
   • 多路召回：结合关键词检索（如 BM25）和向量检索，提升召回率。
   • 重排序：使用更精细的模型对初步检索结果进行重排序，提升精度。
   • 元数据过滤：为文档块添加来源、日期等元数据，检索时进行过滤。

7.4 成本控制

1. 硬件选型：根据并发量和响应时间要求，精确评估所需的 GPU 型号和数量。可以考虑使用推理优化过的模型格式（如 GGUF、AWQ）。
2. 冷热模型：将不常用的模型卸载，仅保留高频模型在 GPU 内存中。
3. 异步处理：对于非实时任务（如文档批量总结），采用消息队列进行异步处理，平滑计算压力。

从本地模型部署、RAG 知识库构建、模型微调到 Dify 应用编排，这条链路覆盖了私有化 AI 应用开发的核心环节。每个环节都有更深入的技术细节可以探索，例如更高效的微调方法、更复杂的检索策略、更灵活的应用工作流等。建议你先按照本文的步骤，在本地或测试环境搭建出最小可行系统，理解数据流和核心配置。然后，针对你最关心的业务场景（如客服、代码助手、文档分析），选择一个环节进行深度优化。真正的“大佬”之路，始于将这套流程在自己的项目中跑通并解决一个实际痛点。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度