# Langflow 可视化 AI 构建器

## 概览

[Langflow](https://github.com/langflow-ai/langflow) 是一款开源的低代码平台，使用可视化拖放界面构建 AI 应用。凭借 55K+ 的 GitHub 收藏和快速增长的社区，它已成为在不编写复杂模板代码的情况下原型设计和部署基于大模型的工作流的首选工具之一。

Langflow 构建于 LangChain 之上，提供了一个图形化编辑器，你可以通过在节点之间绘制连线来连接组件——LLM、向量存储、文档加载器、检索器、agent、工具。生成的流水线可以导出为 API 端点、作为模板共享，或嵌入到你的应用中。

**主要功能：**

* **可视化 RAG 构建器** — 在几分钟内连接文档加载器 → 嵌入 → 向量存储 → 检索器
* **多 agent 工作流** — 使用记忆、工具和决策逻辑串联多个 AI agent
* **LangChain 集成** — 通过 UI 节点访问完整的 LangChain 生态
* **组件市场** — 社区贡献的组件，支持数十种服务
* **API 优先** — 每个 flow 自动生成一个 REST API 端点
* **记忆与状态** — 内置会话记忆、会话管理

**为什么在 Clore.ai 上运行 Langflow？**

Langflow 的计算需求很低——它是一个处理工作流编排的 Python Web 服务器。然而，Clore.ai 可为其打开强大的用例：

* **自托管嵌入模型** — 在 GPU 上运行本地嵌入模型（nomic-embed、BGE），实现快速且免费的向量生成
* **本地 LLM 后端** — 将 Langflow 连接到运行在同一服务器上的 Ollama 或 vLLM
* **私有数据管道** — 在不向外部 API 发送数据的情况下处理敏感文档
* **成本优化** — 用本地免费推理替代昂贵的 OpenAI 嵌入调用
* **持久工作流** — 在专用服务器上运行长期流程（对比短暂的云函数）

***

## 要求

Langflow 本身轻量且基于 CPU。GPU 为可选，但可支持本地 LLM/嵌入的免费推理。

| 配置                         | GPU     | 显存    | 内存    | 存储     | 预计价格            |
| -------------------------- | ------- | ----- | ----- | ------ | --------------- |
| **仅 Langflow（API 后端）**     | 无需      | —     | 4 GB  | 10 GB  | \~$0.03–0.08/小时 |
| **+ 本地嵌入（nomic-embed）**    | 速度      | 24 GB | 8 GB  | 20 GB  | \~$0.20/小时      |
| **+ Ollama（Llama 3.1 8B）** | 速度      | 24 GB | 16 GB | 40 GB  | \~$0.20/小时      |
| **+ Ollama（Qwen2.5 32B）**  | 512x512 | 24 GB | 32 GB | 60 GB  | \~$0.35/小时      |
| **+ vLLM（生产级 RAG）**        | 4 小时会话  | 80 GB | 64 GB | 100 GB | \~$1.10/小时      |

> 有关 Clore.ai 上 GPU 选项的比较，请参阅 [GPU 比较指南](https://docs.clore.ai/guides/guides_v2-zh/kuai-su-ru-men/gpu-comparison).

**Clore.ai 服务器上的软件要求：**

* Docker 引擎（所有 Clore.ai 镜像预装）
* NVIDIA 容器工具包（GPU 镜像预装，仅在使用本地 LLM 时需要）
* 用于 Langflow 镜像和 flow 数据的 10+ GB 可用磁盘空间
* 出站互联网访问（用于拉取 Docker 镜像和访问外部 API）

***

## 快速开始

### 第 1 步：连接到你的 Clore.ai 服务器

在上预订服务器 [Clore.ai 市场](https://clore.ai)。对于仅使用 Langflow 的情况，任何 ≥4 GB 内存的服务器即可。通过 SSH 连接：

```bash
ssh root@<server-ip> -p <ssh-port>
```

### 第 2 步：使用 Docker 运行 Langflow

最简单的部署——单条命令：

```bash
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  langflowai/langflow:latest
```

等待约 30–60 秒启动，然后访问 `http://<server-ip>:7860`

### 第 3 步：在 Clore.ai 上开放 7860 端口

在 Clore.ai 仪表板中，进入你的服务器 → 端口 部分 → 确保 `7860` 已映射。如果使用自定义模板，请在启动服务器前将 `7860:7860` 添加到你的端口配置中。

### 第 4 步：首次启动

首次访问时，Langflow 将：

1. 显示欢迎界面并提示创建帐户（或跳过）
2. 提供一组入门模板（RAG、聊天机器人、agent）
3. 打开可视化画布编辑器

你已准备好构建第一个 flow！

***

## 配置

### 持久数据存储

默认情况下，Langflow 将 flows 和数据存储在容器内。挂载一个卷以在重启间持久化：

```bash
mkdir -p /opt/langflow/data

docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  langflowai/langflow:latest
```

### 环境变量参考

```bash
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_HOST=0.0.0.0 \
  -e LANGFLOW_PORT=7860 \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  -e LANGFLOW_SECRET_KEY=your-secret-key-here \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=your-password \
  -e LANGFLOW_WORKERS=2 \
  -e LANGFLOW_LOG_LEVEL=info \
  langflowai/langflow:latest
```

| 变量                            | 4s            | 默认值         |
| ----------------------------- | ------------- | ----------- |
| `LANGFLOW_HOST`               | 绑定地址          | `0.0.0.0`   |
| `LANGFLOW_PORT`               | Web 服务器端口     | `7860`      |
| `LANGFLOW_DATABASE_URL`       | 数据库连接字符串      | 内存中的 SQLite |
| `LANGFLOW_SECRET_KEY`         | 会话密钥（生产环境请设置） | 随机          |
| `LANGFLOW_AUTO_LOGIN`         | 跳过登录界面        | `true`      |
| `LANGFLOW_SUPERUSER`          | 管理员用户名        | `admin`     |
| `LANGFLOW_SUPERUSER_PASSWORD` | 管理员密码         | —           |
| `LANGFLOW_WORKERS`            | API 工作进程数     | `1`         |
| `LANGFLOW_LOG_LEVEL`          | 日志详细级别        | `critical`  |
| `OPENAI_API_KEY`              | 预加载 OpenAI 密钥 | —           |

### 使用 PostgreSQL（生产环境）

对于多用户或生产部署，请使用 PostgreSQL 替代 SQLite：

```bash
# 启动 PostgreSQL
docker run -d \
  --name langflow-db \
  --restart unless-stopped \
  -e POSTGRES_USER=langflow \
  -e POSTGRES_PASSWORD=langflow-secret \
  -e POSTGRES_DB=langflow \
  -v langflow-pgdata:/var/lib/postgresql/data \
  postgres:16-alpine

# 使用 PostgreSQL 后端启动 Langflow
docker run -d \
  --name langflow \
  --restart unless-stopped \
  --link langflow-db:db \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=postgresql://langflow:langflow-secret@db:5432/langflow \
  -e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32) \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=changeme \
  langflowai/langflow:latest
```

### Docker Compose（完整栈）

用于带有 PostgreSQL 和 Nginx 反向代理的完整部署：

```yaml
# /opt/langflow/docker-compose.yml
version: "3.9"

services:
  langflow:
    image: langflowai/langflow:latest
    restart: unless-stopped
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_DATABASE_URL=postgresql://langflow:secret@db:5432/langflow
      - LANGFLOW_SECRET_KEY=${SECRET_KEY:-changeme}
      - LANGFLOW_AUTO_LOGIN=false
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=${ADMIN_PASSWORD:-changeme}
      - LANGFLOW_WORKERS=2
    volumes:
      - langflow-data:/app/langflow
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=langflow
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=langflow
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U langflow"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  langflow-data:
  pgdata:
```

```bash
cd /opt/langflow
SECRET_KEY=$(openssl rand -hex 32) ADMIN_PASSWORD=yourpassword docker compose up -d
```

### 指定版本固定

为了可复现的部署，请固定特定版本：

```bash
# 列出可用版本：https://hub.docker.com/r/langflowai/langflow/tags
docker run -d \
  --name langflow \
  -p 7860:7860 \
  langflowai/langflow:1.1.4
```

***

## GPU 加速（本地模型集成）

Langflow 本身在 CPU 上运行，但将其连接到同一 Clore.ai 服务器上运行的本地 GPU 服务，可实现免费且私有的推理。

### 将 Langflow 连接到 Ollama

```bash
# 第 1 步：使用 GPU 启动 Ollama
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# 第 2 步：拉取不同用例的模型
docker exec ollama ollama pull llama3.1:8b          # 通用聊天
docker exec ollama ollama pull nomic-embed-text     # 用于 RAG 的嵌入
docker exec ollama ollama pull qwen2.5-coder:7b    # 代码生成

# 第 3 步：启动具有 Ollama 网络访问的 Langflow
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  --add-host host.docker.internal:host-gateway \
  langflowai/langflow:latest
```

在 Langflow UI 中，使用 **Ollama** 组件并设置：

* 基础 URL： `http://host.docker.internal:11434`
* 模型： `llama3.1:8b`

对于嵌入，使用 **OllamaEmbeddings** 组件并设置：

* 基础 URL： `http://host.docker.internal:11434`
* 模型： `nomic-embed-text`

> 完整的 Ollama 配置：参见 [Ollama 指南](https://docs.clore.ai/guides/guides_v2-zh/yu-yan-mo-xing/ollama)

### 将 Langflow 连接到 vLLM（兼容 OpenAI）

```bash
# 使用兼容 OpenAI 的 API 启动 vLLM
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --gpu-memory-utilization 0.85

# 在 Langflow 中，使用带自定义基础 URL 的 OpenAI 组件：
# 基础 URL: http://host.docker.internal:8000/v1
# API Key: （任意值，例如 “none”）
# 模型: mistralai/Mistral-7B-Instruct-v0.3
```

> 完整的 vLLM 配置：参见 [vLLM 指南](https://docs.clore.ai/guides/guides_v2-zh/yu-yan-mo-xing/vllm)

### 构建本地 RAG 流水线

仅使用本地模型的示例 RAG 流（零 API 成本）：

1. **文件加载器** 节点 → 加载 PDF/文本文档
2. **文本拆分器** 节点 → 将文档切块（大小：512，重叠：50）
3. **OllamaEmbeddings** 节点 → 生成嵌入（模型： `nomic-embed-text`)
4. **Chroma** 或 **FAISS** 节点 → 本地存储向量
5. **OllamaEmbeddings** 节点 → 对用户查询进行嵌入
6. **检索器** 节点 → 查找 top-k 相似分块
7. **Ollama** 节点 → 生成答案（模型： `llama3.1:8b`)
8. **聊天输出** 节点 → 返回响应

整个流水线在你的 Clore.ai 服务器上运行，无需任何外部 API 调用。

***

## 提示与最佳实践

### 1. 导出 Flows 作为备份

在停止你的 Clore.ai 服务器之前，导出你的 flows：

* 在 UI 中：Flows → 全选 → 导出 → 下载 JSON
* 或通过 API： `curl http://localhost:7860/api/v1/flows/`

将它们存储在持久卷中或下载到本地机器。

### 2. 使用 API 实现自动化

每个 Langflow flow 都会生成一个 API 端点。以编程方式触发 flow：

```bash
# 从 UI 获取你的 flow ID（显示在 URL 中）
FLOW_ID="your-flow-id-here"

curl -X POST \
  "http://<server-ip>:7860/api/v1/run/$FLOW_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "input_value": "总结最新的 AI 研究论文",
    "input_type": "chat",
    "output_type": "chat"
  }'
```

### 3. 保护你的实例

对于超出本地测试的任何场景：

```bash
# 始终设置认证
-e LANGFLOW_AUTO_LOGIN=false \
-e LANGFLOW_SUPERUSER=admin \
-e LANGFLOW_SUPERUSER_PASSWORD=$(openssl rand -base64 16)

# 使用强密钥
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)
```

### 4. 监控内存使用情况

在多个活跃 flow 情况下，Langflow 的内存可能会随时间增加：

```bash
docker stats langflow
# 如果内存无限增长，请定期重启：
docker restart langflow
```

### 5. 使用入门模板

Langflow 附带生产就绪的模板：

* **基础 RAG** — 使用向量存储的文档问答
* **记忆聊天机器人** — 带有历史记录的对话型 agent
* **研究助理** — 网络搜索 + LLM 综合
* 访问方式：New Flow → Starter Projects

### 6. 组件缓存

启用缓存以加速重复的 flow 运行：

* 在 flow 设置中：对昂贵节点（嵌入、LLM 调用）启用 “Cache”
* 在开发期间对于 RAG 检索特别有用

***

## # 使用固定种子以获得一致结果

### 容器无法启动

```bash
# 检查日志中的错误
docker logs langflow --tail 50

# 常见问题：端口已被占用
lsof -i :7860
# 杀掉冲突进程或更改端口：
docker run ... -p 7861:7860 ...
```

### UI 加载但 Flows 无法运行

```bash
# 检查 worker 进程状态
docker exec langflow ps aux | grep langflow

# 检查是否有 Python 包错误
docker logs langflow 2>&1 | grep -i error

# 重启容器
docker restart langflow
```

### 无法连接到 Ollama

```bash
# 在 Langflow 容器内测试连通性
docker exec langflow curl http://host.docker.internal:11434/api/tags

# 如果缺少 --add-host 标志，请使用以下选项重新创建容器：
--add-host host.docker.internal:host-gateway

# 验证 Ollama 是否正在运行
docker ps | grep ollama
curl http://localhost:11434/api/tags
```

### 重启时的数据库错误

```bash
# 如果使用 SQLite 并遇到锁定错误：
docker stop langflow
ls -la /opt/langflow/data/
# 检查过时的 .lock 文件
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow
```

### 流执行缓慢

```bash
# 增加 workers 以实现并行处理
-e LANGFLOW_WORKERS=4

# 对于以嵌入为主的工作负载，确保 Ollama 使用 GPU：
docker exec ollama nvidia-smi
# 在进行嵌入时应显示 GPU 利用率
```

### 重置管理员密码

```bash
docker exec -it langflow python -c "
from langflow.services.database.utils import initialize_db
from langflow.services.deps import get_settings_service
# 改用 Langflow CLI：
"
# 使用 CLI 方法：
docker exec -it langflow langflow superuser --username admin --password newpassword
```

***

## 延伸阅读

* [Langflow GitHub 仓库](https://github.com/langflow-ai/langflow) — 源代码、问题追踪、变更日志
* [Langflow 文档](https://docs.langflow.org) — 官方文档、组件参考、API 文档
* [Langflow Discord](https://discord.com/invite/EqksyE2EX9) — 社区支持与 flow 分享
* [Clore.ai 上的 Ollama](https://docs.clore.ai/guides/guides_v2-zh/yu-yan-mo-xing/ollama) — 为 Langflow 设置本地 LLM 后端
* [Clore.ai 上的 vLLM](https://docs.clore.ai/guides/guides_v2-zh/yu-yan-mo-xing/vllm) — 用于生产流程的高吞吐量 LLM 服务
* [GPU 比较指南](https://docs.clore.ai/guides/guides_v2-zh/kuai-su-ru-men/gpu-comparison) — 为你的工作负载选择合适的 Clore.ai GPU
* [LangChain 文档](https://python.langchain.com/docs/) — 底层框架参考
* [Docker Hub: langflowai/langflow](https://hub.docker.com/r/langflowai/langflow) — 可用镜像标签与版本