最近在跟进AI领域动态时，发现无论是底层模型还是上层应用，迭代速度都让人应接不暇。对于开发者而言，既要关注技术前沿，又得思考如何将这些能力快速、稳定地集成到自己的产品中。本文将聚焦于近期值得关注的AI工程实践与模型部署趋势，并结合一个名为“Pokee”的新兴AI应用平台（以其作为功能体验案例），拆解一套从概念到落地的完整技术路径。无论你是想了解AI应用开发的最新风向，还是正在寻找高效的模型部署方案，这篇文章都能提供直接的参考和可复用的代码示例。

1. AI工程化与模型部署的核心挑战与趋势

在谈论具体工具之前，我们有必要厘清当前AI项目落地过程中的核心痛点。这不再是简单的调用一个API，而是涉及数据、算力、流程和运维的系统工程。

1.1 从原型到生产：工程化鸿沟

许多团队在Jupyter Notebook中训练出一个表现良好的模型后，会发现将其转化为一个可维护、可扩展、高可用的生产服务困难重重。主要挑战包括：

  • 环境依赖复杂 ：训练环境和生产环境（操作系统、Python版本、CUDA驱动、依赖库）的不一致，导致“在我机器上能跑”的经典问题。
  • 资源管理与扩展性 ：模型推理需要消耗计算资源（尤其是GPU），如何高效地管理资源、实现自动扩缩容以应对流量波动？
  • 版本管理与回滚 ：模型迭代频繁，如何像管理代码一样管理模型版本，并能在出现问题时快速回滚？
  • 监控与可观测性 ：生产中的模型性能如何？是否有预测延迟增加、准确率下降（数据漂移）？需要完善的监控体系。

1.2 模型部署模式演进

针对上述挑战，部署模式也在不断进化：

  • 模式一：嵌入式部署 。将模型直接打包到应用程序中（如手机App、边缘设备）。优点是离线、低延迟；缺点是受终端资源限制，难以更新。
  • 模式二：云端服务化（Model-as-a-Service） 。将模型封装成RESTful API或gRPC服务，这是目前最主流的方式。它解决了环境隔离和资源管理的问题，Spring AI等框架正在简化这一过程。
  • 模式三：Serverless推理 。将模型部署在无服务器函数上，按需调用，按使用量计费。极大简化了运维，适合流量不确定或间歇性请求的场景。
  • 模式四：专用推理服务器 。使用像 TensorFlow Serving 、 TorchServe 或 Triton Inference Server 这样的高性能专用系统。它们提供了批处理、模型仓库、多模型并行等高级特性，是复杂生产环境的首选。

1.3 相关技术生态剪影

从网络热词中，我们可以看到几个关键的技术焦点：

  • Spring AI ：旨在将AI能力无缝集成到Spring Boot应用中，提供统一的API访问多种大模型（OpenAI、Azure OpenAI、Ollama等），大大降低了Java生态中集成AI的门槛。
  • AI Agent开发 ：智能体（Agent）是能感知环境、进行决策和执行动作的AI系统。其开发涉及规划、工具使用、记忆等模块，是构建复杂AI应用的前沿。
  • Cursor AI / AI编程工具 ：这类工具通过深度理解代码上下文，辅助开发者编写、重构和调试代码，正在改变软件开发范式。
  • 模型部署与运维 ：如何将训练好的模型（尤其是大模型）高效、稳定地部署上线，是“AI工程实践”的核心。

接下来，我们将以体验一个具备AI功能的应用平台“Pokee”为例，贯穿上述部分理念，并重点落在 如何构建和部署一个类似的AI服务 上。

2. 环境准备与项目初始化

在开始构建之前，我们需要搭建一个标准化、可复现的开发环境。本次实战我们将以构建一个提供“智能文本摘要”服务的后端API为例，技术栈选择Python（因其在AI领域的广泛生态）和FastAPI（轻量级高性能框架）。

2.1 基础环境说明

  • 操作系统 ：Ubuntu 20.04+ / macOS / Windows (WSL2推荐)。本文命令以Linux/macOS为例。
  • Python版本 ：3.8 - 3.10。推荐使用3.9以保证兼容性。
  • 包管理工具 ： pip 和 venv （用于创建虚拟环境）。
  • 版本控制 ：Git。
  • 可选：容器环境 ：Docker & Docker Compose，用于最终的生产部署。

2.2 创建项目并隔离环境

首先，创建一个干净的项目目录并初始化虚拟环境。 

# 创建项目目录
mkdir ai-summary-service && cd ai-summary-service

# 创建Python虚拟环境
python3 -m venv venv

# 激活虚拟环境
# Linux/macOS
source venv/bin/activate
# Windows
# venv\Scripts\activate

# 升级pip
pip install --upgrade pip

2.3 初始化项目结构

一个清晰的项目结构是良好工程实践的起点。 

# 创建基础目录和文件
mkdir -p app/{core, models, schemas, api, utils}
touch app/__init__.py
touch app/core/__init__.py
touch app/models/__init__.py
touch app/schemas/__init__.py
touch app/api/__init__.py
touch app/utils/__init__.py
touch main.py
touch requirements.txt
touch Dockerfile
touch docker-compose.yml

当前项目结构如下： 

ai-summary-service/
├── app/                    # 应用主目录
│   ├── core/              # 核心配置、常量等
│   ├── models/            # 数据模型（如Pydantic模型、数据库ORM模型）
│   ├── schemas/           # API请求/响应模型（Pydantic）
│   ├── api/               # 路由端点
│   └── utils/             # 工具函数
├── main.py                # 应用入口
├── requirements.txt       # Python依赖列表
├── Dockerfile             # Docker构建文件
└── docker-compose.yml     # Docker编排文件

3. 核心依赖与模型选择

我们的服务需要一个文本摘要模型。为了平衡效果、速度和部署难度，我们选择使用 Hugging Face Transformers 库中的预训练模型，而不是从零开始训练。

3.1 编写requirements.txt

在 requirements.txt 中定义项目依赖。 

# Web框架
fastapi==0.104.1
uvicorn[standard]==0.24.0

# AI/ML核心库
torch==2.1.0
transformers==4.35.0
sentencepiece==0.1.99  # 某些Tokenizer需要

# 工具与工具链
pydantic==2.5.0
pydantic-settings==2.1.0
python-dotenv==1.0.0
httpx==0.25.1

# 开发与质量保障
pytest==7.4.3
black==23.11.0

安装依赖 ： 

pip install -r requirements.txt

3.2 模型选择与加载逻辑

我们选择 facebook/bart-large-cnn 模型，它在文本摘要任务上表现良好且易于使用。在 app/core/model.py 中编写模型加载单例。 

# 文件路径：app/core/model.py
import torch
from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
from typing import Optional
import logging

logger = logging.getLogger(__name__)

class SummaryModel:
    """摘要模型单例封装类，负责加载和运行模型"""
    _instance = None
    _model = None
    _tokenizer = None
    _pipe = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(SummaryModel, cls).__new__(cls)
            cls._instance._initialize_model()
        return cls._instance

    def _initialize_model(self):
        """初始化模型和分词器，使用pipeline简化调用"""
        model_name = "facebook/bart-large-cnn"
        logger.info(f"正在加载模型: {model_name}")
        try:
            # 使用pipeline，它会自动处理模型和tokenizer的加载
            self._pipe = pipeline(
                "summarization",
                model=model_name,
                tokenizer=model_name,
                device=0 if torch.cuda.is_available() else -1  # 使用GPU如果可用
            )
            logger.info(f"模型加载成功，设备: {'GPU' if torch.cuda.is_available() else 'CPU'}")
        except Exception as e:
            logger.error(f"模型加载失败: {e}")
            raise

    def predict(self, text: str, max_length: int = 130, min_length: int = 30) -> str:
        """执行文本摘要预测"""
        if not text or len(text.strip()) < 10:
            return "输入文本过短，无法生成有效摘要。"

        try:
            # 调用pipeline进行摘要生成
            result = self._pipe(
                text,
                max_length=max_length,
                min_length=min_length,
                do_sample=False,  # 不使用采样，保证确定性输出（适合调试）
            )
            summary = result[0]['summary_text']
            return summary.strip()
        except Exception as e:
            logger.error(f"预测过程中发生错误: {e}")
            return f"摘要生成失败: {str(e)}"

# 全局可用的模型实例
summary_model = SummaryModel()

关键点解释 ：

  1. 单例模式 ：确保模型在内存中只加载一次，避免每次请求都重复加载的巨大开销。
  2. Pipeline ：Hugging Face的 pipeline 抽象了预处理、模型推理和后处理的完整流程，极大简化了使用方式。
  3. 设备检测 ： device 参数自动检测CUDA，让代码在有无GPU的环境下都能运行。
  4. 错误处理 ：对输入和推理过程进行了基本的异常捕获，避免服务因单个请求崩溃。

4. 构建完整的FastAPI服务

有了模型核心，我们现在需要构建一个完整的Web服务来暴露它的能力。

4.1 定义数据模型（Pydantic Schemas）

在 app/schemas/summary.py 中定义API的请求和响应格式。 

# 文件路径：app/schemas/summary.py
from pydantic import BaseModel, Field
from typing import Optional

class SummaryRequest(BaseModel):
    """摘要生成请求体"""
    text: str = Field(..., min_length=10, description="需要被摘要的原始文本，长度至少10字符")
    max_length: Optional[int] = Field(130, ge=30, le=200, description="摘要最大长度，默认130")
    min_length: Optional[int] = Field(30, ge=10, le=100, description="摘要最小长度，默认30")

    class Config:
        schema_extra = {
            "example": {
                "text": "人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能是计算机科学的一个分支，它企图了解智能的实质，并生产出一种新的能以人类智能相似的方式做出反应的智能机器，该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。",
                "max_length": 150,
                "min_length": 50
            }
        }

class SummaryResponse(BaseModel):
    """摘要生成响应体"""
    original_length: int = Field(..., description="原始文本长度")
    summary_length: int = Field(..., description="生成的摘要长度")
    summary: str = Field(..., description="生成的摘要文本")
    processing_time_ms: Optional[float] = Field(None, description="处理耗时（毫秒）")

4.2 创建API路由端点

在 app/api/endpoints/summary.py 中创建处理HTTP请求的路由。 

# 文件路径：app/api/endpoints/summary.py
import time
from fastapi import APIRouter, HTTPException
from app.schemas.summary import SummaryRequest, SummaryResponse
from app.core.model import summary_model
import logging

router = APIRouter(prefix="/summary", tags=["summary"])
logger = logging.getLogger(__name__)

@router.post("/", response_model=SummaryResponse)
async def create_summary(request: SummaryRequest):
    """
    接收文本，返回其AI生成的摘要。
    """
    start_time = time.time()
    logger.info(f"收到摘要请求，文本长度: {len(request.text)}")

    # 调用模型进行预测
    summary_text = summary_model.predict(
        text=request.text,
        max_length=request.max_length,
        min_length=request.min_length
    )

    processing_time_ms = (time.time() - start_time) * 1000

    # 构建响应
    response = SummaryResponse(
        original_length=len(request.text),
        summary_length=len(summary_text),
        summary=summary_text,
        processing_time_ms=round(processing_time_ms, 2)
    )

    logger.info(f"请求处理完成，耗时: {response.processing_time_ms}ms")
    return response

4.3 配置应用主文件

在 main.py 中整合所有部分，并添加一些基本的中间件和配置。 

# 文件路径：main.py
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
import logging
from app.api.endpoints import summary

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 创建FastAPI应用实例
app = FastAPI(
    title="AI文本摘要服务",
    description="基于BART-large-CNN模型提供高质量的文本摘要生成API",
    version="1.0.0"
)

# 添加CORS中间件（允许前端跨域访问）
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 生产环境应替换为具体的前端域名
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 包含路由
app.include_router(summary.router)

@app.get("/")
async def root():
    """健康检查端点"""
    return {"message": "AI Summary Service is running", "status": "healthy"}

@app.on_event("startup")
async def startup_event():
    """应用启动时执行，预加载模型"""
    # 导入模型实例会触发其初始化
    from app.core.model import summary_model
    logger.info("服务启动，模型预加载完成。")

if __name__ == "__main__":
    import uvicorn
    # 使用uvicorn运行，主机0.0.0.0允许外部访问，端口8000
    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)  # reload=True仅用于开发

5. 运行、测试与验证

5.1 本地启动服务

在项目根目录下，运行： 

python main.py

或使用uvicorn命令： 

uvicorn main:app --host 0.0.0.0 --port 8000 --reload

看到类似以下输出，说明服务启动成功： 

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     app.core.model: 正在加载模型: facebook/bart-large-cnn
INFO:     app.core.model: 模型加载成功，设备: CPU
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

5.2 使用API测试

打开浏览器访问 http://localhost:8000/docs ，你会看到自动生成的Swagger UI交互式文档。

手动测试（使用curl） ： 

curl -X POST "http://localhost:8000/summary/" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "OpenAI发布了新一代大型语言模型GPT-4，该模型在多种专业和学术基准测试中表现出人类水平的能力。例如，它在模拟律师考试中的得分排名前10%的考生，相比之下，GPT-3.5的得分排名在后10%。GPT-4是一个多模态模型，可以接受图像和文本输入，并产生文本输出。虽然在许多现实场景中不如人类，但GPT-4在各种专业测试中表现出与人类相当的性能。",
    "max_length": 100,
    "min_length": 40
  }'

预期响应 ： 

{
  "original_length": 350,
  "summary_length": 85,
  "summary": "OpenAI发布了新一代大型语言模型GPT-4，该模型在多种专业和学术基准测试中表现出人类水平的能力。它在模拟律师考试中的得分排名前10%的考生。GPT-4是一个多模态模型，可以接受图像和文本输入，并产生文本输出。",
  "processing_time_ms": 1200.5
}

5.3 编写简单单元测试

在项目根目录创建 test_api.py 。 

# 文件路径：test_api.py
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_root():
    """测试根端点"""
    response = client.get("/")
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

def test_summary_endpoint():
    """测试摘要生成端点"""
    test_text = "FastAPI是一个现代、快速（高性能）的Web框架，用于基于标准Python类型提示构建API。其主要特性包括：快速、易于使用、标准化、基于开放标准。"
    payload = {
        "text": test_text,
        "max_length": 80,
        "min_length": 20
    }
    response = client.post("/summary/", json=payload)
    assert response.status_code == 200
    data = response.json()
    assert "summary" in data
    assert len(data["summary"]) > 0
    assert data["original_length"] == len(test_text)
    assert data["summary_length"] <= payload["max_length"]
    print(f"测试通过！生成的摘要：{data['summary']}")

if __name__ == "__main__":
    test_root()
    test_summary_endpoint()

运行测试： 

python test_api.py

6. 生产环境部署：Docker化与最佳实践

本地开发完成后，我们需要将服务容器化，以便在任何支持Docker的环境（如云服务器、Kubernetes）中一致地运行。

6.1 编写Dockerfile 

# 文件路径：Dockerfile
# 使用官方Python精简版镜像作为基础
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 设置环境变量，防止Python输出被缓冲
ENV PYTHONUNBUFFERED=1 \
    # 禁用pip的版本检查，减少日志噪音
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# 安装系统依赖（如需要编译某些Python包）
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    g++ \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件并安装
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口（与main.py中uvicorn运行的端口一致）
EXPOSE 8000

# 运行服务，使用生产级服务器（如uvicorn搭配多个worker）
# 注意：这里使用`main:app`，其中`main`是模块名，`app`是FastAPI实例名
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

6.2 编写docker-compose.yml（用于简化本地多服务编排） 

# 文件路径：docker-compose.yml
version: '3.8'

services:
  ai-summary-service:
    build: .
    container_name: ai-summary-service
    ports:
      - "8000:8000"
    environment:
      - TZ=Asia/Shanghai
      # 可以在这里添加其他环境变量，如模型路径、日志级别等
    # 设置资源限制
    deploy:
      resources:
        limits:
          memory: 2G
          cpus: '1.0'
    # 健康检查
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    restart: unless-stopped
    # 挂载卷，便于开发时热更新代码（生产环境不建议）
    # volumes:
    #   - ./app:/app/app

6.3 构建并运行Docker容器 

# 构建Docker镜像
docker build -t ai-summary-service:latest .

# 使用docker-compose启动（推荐）
docker-compose up -d

# 或者直接使用docker run
# docker run -d -p 8000:8000 --name my-ai-service ai-summary-service:latest

6.4 生产环境进阶配置建议

  1. 使用Gunicorn作为进程管理器 ：对于生产环境，通常使用Gunicorn管理多个Uvicorn worker进程，以更好地利用多核CPU并提高稳定性。修改Dockerfile中的CMD： 
    CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "main:app", "-b", "0.0.0.0:8000"]
  2. 配置日志 ：将日志输出到标准输出（stdout/stderr），方便Docker和Kubernetes收集。使用Python的 logging 库配置JSON格式的日志。
  3. 环境变量管理 ：使用 pydantic-settings 管理敏感配置（如API密钥、数据库连接），通过环境变量注入。
  4. 健康检查与就绪探针 ：Kubernetes中需要配置 livenessProbe 和 readinessProbe ，确保服务状态可控。
  5. 资源限制与请求 ：在Kubernetes的Deployment中明确设置CPU和内存的 limits 与 requests ，防止单个Pod耗尽节点资源。

7. 常见问题与排查思路

在开发部署过程中，你可能会遇到以下问题：

问题现象 可能原因 排查步骤与解决方案
服务启动失败，提示模型下载错误 网络问题，无法从Hugging Face Hub下载模型。 1. 检查网络连接。
2. 设置镜像或代理： export HF_ENDPOINT=https://hf-mirror.com 。
3. 提前下载模型到本地，修改代码从本地路径加载。
推理速度非常慢 1. 模型在CPU上运行。
2. 输入文本过长。
3. Docker容器资源不足。 		1. 确认CUDA可用： print(torch.cuda.is_available()) 。
2. 在请求中限制 max_length ，或在服务端对长文本进行分段处理。
3. 检查Docker容器的CPU/内存限制，确保足够。
内存占用过高，服务被OOM Kill 1. 模型本身较大。
2. 并发请求过多，未做限流。
3. Docker内存限制设置过小。 		1. 考虑使用更小的模型（如 distilbart-cnn-12-6 ）。
2. 在API网关或应用层添加速率限制。
3. 增加Docker容器的内存限制，或使用K8s的垂直扩缩容。
API响应返回“摘要生成失败” 1. 输入文本格式异常（如包含大量乱码）。
2. 模型推理过程中出现内部错误。 		1. 在API层增加输入文本的清洗和验证逻辑（如编码检查、长度截断）。
2. 查看服务日志（ docker logs <container_id> ）获取详细的错误堆栈信息。
Docker构建时下载依赖超时 pip源网络不稳定。 在Dockerfile中更换pip源：
RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

8. 工程最佳实践与扩展方向

8.1 模型服务化进阶

  • 使用专用推理服务器 ：对于更高吞吐量和更复杂的模型（如多模态、大语言模型），将模型部署到 Triton Inference Server 或 TorchServe 中，并通过HTTP/gRPC与业务服务通信。它们支持动态批处理、模型集成、性能监控等高级特性。
  • 模型版本管理与A/B测试 ：建立模型仓库，管理不同版本的模型。通过API网关或特征开关，将部分流量导向新模型版本，进行A/B测试，验证效果后再全量。
  • 异步处理与队列 ：对于耗时长（如图像生成、长文本总结）的推理任务，不应阻塞HTTP请求。可以采用“请求-响应-轮询”或“发布-订阅”模式，使用Redis、RabbitMQ或Kafka作为任务队列。

8.2 监控与可观测性

  • 业务指标 ：记录每个请求的原始文本长度、摘要长度、处理时间、模型版本。
  • 系统指标 ：监控服务的CPU、内存、GPU使用率，以及请求QPS、延迟、错误率。
  • 模型性能指标 ：定期用一批标准测试数据评估模型的摘要质量（如ROUGE分数），监控数据漂移。
  • 集成工具 ：使用Prometheus收集指标，Grafana进行可视化，ELK或Loki收集日志。

8.3 安全与合规

  • 输入验证与清理 ：严格验证用户输入，防止注入攻击。对文本进行必要的清理，移除敏感信息。
  • 速率限制 ：在API网关（如Nginx, Kong）或应用层实现速率限制，防止恶意爬取或DDoS攻击。
  • 访问控制 ：为API添加认证（如JWT Token、API Key），确保只有授权用户或服务可以调用。
  • 内容审核 ：对于生成式AI应用，需在后端或模型输出层添加内容安全过滤器，确保生成内容符合法律法规。

8.4 扩展至更复杂的AI应用

本文的“文本摘要”是一个具体任务。你可以将此架构作为模板，扩展到其他AI能力：

  1. 替换模型 ：将 app/core/model.py 中的模型换成其他Hugging Face pipeline支持的任务，如 "text-classification" （情感分析）、 "text-generation" （文本生成）、 "translation" （翻译）。
  2. 构建AI Agent ：利用LangChain等框架，将多个模型（LLM、Embedding）和工具（搜索、计算器、API调用）串联起来，实现复杂的推理和工作流。这对应了热词中的“AI Agent开发”。
  3. 集成Spring AI ：如果你的主力技术栈是Java，可以探索 Spring AI 项目，它提供了类似的抽象，让你能在Spring Boot应用中轻松集成OpenAI、Azure OpenAI或本地Ollama模型。

通过以上步骤，我们完成了一个从零开始构建、测试到容器化部署的AI服务。这个过程涵盖了模型加载、API开发、测试验证和生产部署的关键环节，其模式可以复用于大多数AI能力服务化的场景。

Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区