RDK s100p跑llm大语言模型，可以使用bpu算力吗，可以的话，怎么才能使用上呢

sky77777 · 2026 年4 月 9 日 08:40

地瓜小助手_bot · 2026 年4 月 9 日 08:40

结论

可以，但有条件限制：

视觉部分：可以运行在 BPU 上（已有成熟方案）
语言部分（LLM）：目前官方工具链仅支持特定模型的 BPU 部署，且处于逐步完善阶段

当前可用方案

方案一：使用官方 LLM 工具链（推荐）

参考文档：7.4.2 LLM 工具链 | RDK DOC

步骤：

# 1. 配置系统性能模式
sudo /usr/bin/set_performance_mode.sh

# 2. 配置 ION 内存（srpi-config 工具）
# 设置为最大可用内存

# 3. 模型转换（以 Qwen2.5 Omni 3B 为例）
# 按照文档步骤将模型转换为 HBM + GGUF 格式

# 4. 运行推理
./llm_demo --model_path <your_model_path>

关键配置：

内存分配模式：推荐使用 balanced（比 bpu_first 更稳定）
支持模型：Qwen2.5 Omni 3B 等官方验证过的模型

方案二：hobot_llamacpp（视觉+BPU，语言+CPU）

参考：hobot_llamacpp GitHub

现状：

视觉部分：运行在 BPU
语言部分：目前仍运行在 CPU（官方回复：语言部分 BPU 运行方案尚未发布）

重要注意事项

问题	说明
内存分配	S100P 的 BPU SRAM 有限（约 512MB~1GB），大模型需配合 ION Buffer
模式选择	`balanced` 模式比 `bpu_first` 更稳定，适合 3B 级别模型
模型限制	目前仅支持官方转换过的模型，自定义模型需按工具链流程转换
持久性	性能模式设置后重启一般仍有效，无需每次执行脚本

排查路径

如果遇到 BPU IOMMU MAP failed 错误：

# 1. 检查当前模式
cat /sys/class/bpu/bpu0/memory_layout

# 2. 查看 BPU 状态
sudo rdkos_info -s | grep bpu

# 3. 尝试切换到 balanced 模式
# 修改 omni_offline_config.json 中的 memory_layout 字段

建议

先跑通官方 Demo：按照 LLM 工具链文档，先用 Qwen2.5 Omni 3B 验证环境
关注社区更新：语言部分 BPU 加速方案正在开发中
有问题发帖子：您这个问题已经有人遇到了，可以在原帖下跟进最新进展

需要我帮您查找具体的模型转换教程或配置示例吗？

Marcelo · 2026 年4 月 10 日 05:02

你好，可以参考手册第七章节 LLM手册

sky77777 · 2026 年4 月 13 日 10:09

感谢，如果我在rdks100p上部署的模型，我想要兼容langchain框架，也就是初始化出来的模型，可以适配langchain生态进行开发，需要怎么实现呢，有参考文档吗

sky77777 · 2026 年4 月 13 日 10:10

如果我在rdks100p上部署的模型，我想要兼容langchain框架，也就是初始化出来的模型，可以适配langchain生态进行开发，需要怎么实现呢，有参考文档吗

地瓜小助手_bot · 2026 年4 月 13 日 10:11

结论

可以兼容 LangChain，但需要搭建 API 服务层。

RDK S100P 上部署的模型（通过 hobot_llamacpp 或官方 LLM 工具链）本质是 C++ 可执行程序，不直接支持 LangChain。LangChain 需要连接一个 OpenAI 兼容的 API 服务。

核心方案：
在 S100P 上运行 llama.cpp 的 Server 模式（提供 HTTP API），然后在你的开发机（或板端 Python 环境）使用 LangChain 连接该 API。

实现路径

方案一：使用 llama.cpp Server（推荐，最成熟）

hobot_llamacpp 基于 llama.cpp 修改，但官方 llama.cpp 原生支持 Server 模式。如果你的模型是 GGUF 格式（语言部分），可以直接用原生 llama.cpp server。

步骤 1：确认模型格式

语言模型必须是 .gguf 格式（如 Qwen2.5-0.5B-Instruct-Q4_0.gguf）。
视觉模型部分（.hbm）无法通过标准 API 暴露，LangChain 主要处理文本，建议先聚焦纯 LLM 部分。

步骤 2：编译并启动 Server（在 S100P 上）

# 1. 进入 llama.cpp 目录（hobot_llamacpp 已链接）
cd ~/hobot_llamacpp/llama.cpp

# 2. 编译 server 示例（如果未编译）
cmake -B build
cmake --build build --config Release --target server

# 3. 启动 API 服务（监听 0.0.0.0:8080）
./build/bin/server \
  -m /path/to/your/Qwen2.5-0.5B-Instruct-Q4_0.gguf \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080 \
  -np 4  # 并行请求数

步骤 3：LangChain 连接（在开发机或板端 Python）

from langchain_community.llms import LlamaCpp
from langchain_core.prompts import PromptTemplate

# 方式 A：直接使用 LlamaCpp 集成（推荐，无需 HTTP）
# 需要板端安装 llama-cpp-python (编译较麻烦，需链接 BPU 库)
llm = LlamaCpp(
    model_path="/path/to/Qwen2.5-0.5B-Instruct-Q4_0.gguf",
    n_ctx=4096,
    n_threads=4,
    verbose=False,
)

# 方式 B：通过 HTTP API 连接（更灵活，解耦）
from langchain_community.llms import Ollama  # 或自定义 OpenAI 兼容接口

# 如果 llama.cpp server 开启了 OpenAI 兼容模式：
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="http://<S100P_IP>:8080/v1",  # llama.cpp server 地址
    api_key="not-needed",  # 本地服务无需密钥
    model="local-model",
)

# 测试
response = llm.invoke("你好，请介绍下地瓜机器人")
print(response.content)

方案二：使用 OpenClaw 作为中间层（社区已有案例）

社区已有 OpenClaw 在 RDK 上的部署案例（见帖子 34227），它是一个 AI 网关，可以代理大模型 API。

优势：

支持多种后端（包括本地 llama.cpp）
提供统一的 OpenAI 兼容接口
易于集成到 LangChain

步骤：

参考社区帖子部署 OpenClaw 到 S100P。
配置 OpenClaw 后端指向你的 hobot_llamacpp 或 llama.cpp server。
LangChain 连接 OpenClaw 的 API 地址。

关键限制与注意事项

问题	说明	解决方案
视觉部分无法 API 化	`hobot_llamacpp` 的 VLM 功能依赖 ROS2 Topic，不是 HTTP API	LangChain 主要处理文本，视觉部分需单独用 ROS2 节点处理，再将结果传给 LLM
BPU 加速的 LLM 部分	目前官方工具链的 LLM on BPU 还在完善中	先用 CPU 跑 GGUF 模型（`llama.cpp`），等官方发布 BPU LLM API
性能	S100P 的 CPU 跑 3B 模型较慢	使用量化模型（Q4_K_M），或等待 BPU LLM 方案成熟
Python 环境	板端 Python 可能缺少依赖	建议使用 `pip install langchain langchain-community`，注意 ARM64 兼容性

下一步建议

先跑通纯文本 LLM：用 llama.cpp server 启动 Qwen2.5-0.5B（GGUF 格式），LangChain 连接测试。
再考虑视觉部分：通过 ROS2 Topic 获取图像描述，作为 Prompt 输入 LangChain。
关注官方更新：BPU LLM 的 API 化方案正在开发中，后续可能直接支持。

需要我帮你写一个完整的 LangChain + llama.cpp server 的 Demo 脚本吗？

地瓜小助手_bot · 2026 年4 月 13 日 10:11

结论

可以实现，但目前社区没有“一键安装包”，需要你自己部署一个 API 桥接服务。

LangChain 通常通过 HTTP API (OpenAI 兼容) 调用模型，而 RDK S100P 上的 hobot_llamacpp 或官方 LLM 工具链默认是 ROS 2 节点 或 命令行程序。

核心方案：在 S100P 上运行一个轻量级 Python FastAPI 服务，作为“翻译官”，将 HTTP 请求转发给 ROS 2 推理节点，再将结果返回给 LangChain。

实施架构

[LangChain (PC/Server)] <==HTTP/OpenAI API==> [FastAPI 桥接服务 (S100P)] <==ROS2 Topic==> [hobot_llamacpp (S100P/BPU)]

详细步骤

步骤 1：确认推理环境正常

确保你的 hobot_llamacpp 已经在 S100P 上正常运行，并能通过 ROS 2 Topic 收发数据。

输入 Topic: /prompt_text (std_msgs/msg/String)
输出 Topic: /llama_cpp_node (std_msgs/msg/String)

步骤 2：编写 FastAPI 桥接服务

在 S100P 上创建一个 Python 脚本 llm_api_bridge.py。该脚本负责启动 HTTP 服务，并通过 ROS 2 与模型通信。

前置依赖：

# 在 S100P 上安装
pip3 install fastapi uvicorn ros2-py

代码示例 (llm_api_bridge.py)：

import rclpy
from rclpy.node import Node
from std_msgs.msg import String
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import threading
import time

app = FastAPI()

# 用于存储最新的推理结果
latest_response = {"content": "", "done": True}

class ChatRequest(BaseModel):
    message: str
    # 可扩展：temperature, max_tokens 等参数

class LlmBridgeNode(Node):
    def __init__(self):
        super().__init__('llm_bridge_node')
        # 发布提示词
        self.pub = self.create_publisher(String, '/prompt_text', 10)
        # 订阅推理结果
        self.sub = self.create_subscription(String, '/llama_cpp_node', self.listener_callback, 10)
        
    def listener_callback(self, msg):
        latest_response["content"] = msg.data
        latest_response["done"] = True

# 全局 ROS 节点实例
ros_node = None
ros_thread = None

def run_ros():
    global ros_node
    rclpy.init()
    ros_node = LlmBridgeNode()
    rclpy.spin(ros_node)

@app.on_event("startup")
async def start_ros():
    global ros_thread
    ros_thread = threading.Thread(target=run_ros, daemon=True)
    ros_thread.start()
    time.sleep(2) # 等待 ROS 初始化

@app.post("/v1/chat/completions")
async def chat_completion(request: ChatRequest):
    if ros_node is None:
        raise HTTPException(status_code=503, detail="ROS node not ready")
    
    # 重置状态
    latest_response["content"] = ""
    latest_response["done"] = False
    
    # 发送提示词
    msg = String()
    msg.data = request.message
    ros_node.pub.publish(msg)
    
    # 简单轮询等待结果 (生产环境建议用异步队列)
    timeout = 60 # 超时 60 秒
    start_time = time.time()
    while not latest_response["done"]:
        if time.time() - start_time > timeout:
            raise HTTPException(status_code=504, detail="Inference timeout")
        time.sleep(0.1)
        
    return {
        "choices": [{
            "message": {"role": "assistant", "content": latest_response["content"]},
            "finish_reason": "stop"
        }],
        "model": "rdk-s100p-llm"
    }

if __name__ == "__main__":
    import uvicorn
    # 监听 0.0.0.0 允许局域网访问
    uvicorn.run(app, host="0.0.0.0", port=8000)

步骤 3：启动服务

在 S100P 上同时运行推理节点和 API 服务：

终端 1 (运行推理)：

source /opt/ros/humble/setup.bash
source ./install/setup.bash
ros2 run hobot_llamacpp hobot_llamacpp --ros-args -p feed_type:=2 -p llm_model_name:=Qwen2.5-0.5B-Instruct-Q4_0.gguf

终端 2 (运行 API 桥接)：

source /opt/ros/humble/setup.bash
python3 llm_api_bridge.py

步骤 4：LangChain 调用配置

在你的开发机（PC/服务器）上，使用 LangChain 连接 S100P 的 IP。

from langchain_openai import ChatOpenAI

# 假设 S100P 的 IP 是 192.168.1.100
llm = ChatOpenAI(
    base_url="http://192.168.1.100:8000/v1", # 指向 S100P 的 API
    api_key="not-needed", # 本地服务通常不需要 key
    model="rdk-s100p-llm"
)

response = llm.invoke("你好，RDK S100P 的 BPU 算力怎么样？")
print(response.content)

关键注意事项

问题	说明与建议
并发性能	S100P 算力有限，不支持高并发。建议在 FastAPI 中加锁，同一时间只处理一个请求，避免 BPU 过载。
流式输出	上述示例是“一次性返回”。若需打字机效果（Stream），需修改 FastAPI 使用 `StreamingResponse` 并配合 ROS 的中间结果 Topic (`/tts_text`)。
网络延迟	确保 PC 和 S100P 在同一局域网，最好用网线直连或 5G WiFi，减少 HTTP 传输延迟。
模型选择	LangChain 应用通常交互频繁，建议使用 Qwen2.5-0.5B/1.5B 等小模型，3B 模型在 S100P 上首字延迟可能较高，影响体验。

进阶优化建议

直接使用 llama.cpp server：
如果你熟悉编译，可以尝试在 hobot_llamacpp 集成的 llama.cpp 源码中，查找是否保留了 examples/server。如果该版本支持 BPU 且能编译出 server 可执行文件，直接运行 ./server -m model.gguf --host 0.0.0.0 即可原生支持 OpenAI API，无需写桥接代码。（注：需验证 BPU 加速在该 server 示例中是否生效）
容器化部署：
将推理节点和 API 服务打包成 Docker 容器，方便一键启动和管理。

社区资源

hobot_llamacpp 源码：GitHub - D-Robotics/hobot_llamacpp
相关讨论：论坛中已有用户讨论如何在 S100 上部署 LLM，可参考其中的内存配置优化。

如果你在编写桥接代码时遇到 ROS 2 通信问题，或者需要流式输出的具体代码实现，欢迎随时发帖询问！

sky77777 · 2026 年4 月 13 日 10:15

如果我在rdks100p上部署的模型，我想要兼容langchain框架，也就是初始化出来的模型，可以适配langchain生态进行开发，需要怎么实现呢，有参考文档吗，前提是我需要使用bpu算力。

地瓜小助手_bot · 2026 年4 月 13 日 10:16

结论

可以实现，但需要“自研 API 服务层”，社区目前无现成方案。

核心矛盾在于：

hobot_llamacpp：视觉部分用 BPU，但语言部分（LLM）目前主要运行在 CPU（官方已确认，见帖子 33716）。
官方 LLM 工具链：支持 LLM 在 BPU 上运行（如 Qwen2.5 Omni），但仅提供命令行 Demo 或 C++ 库，没有 HTTP Server。
LangChain：需要 OpenAI 兼容的 HTTP API。

因此，若要坚持“LLM 部分也用 BPU"，你必须使用【官方 LLM 工具链】+【自研 API 封装】。

实施架构

[LangChain (PC)] <==HTTP/OpenAI API==> [自研 API 服务 (S100P)] <==C++ SDK==> [官方 LLM 工具链 (BPU 加速)]

详细步骤

步骤 1：确认推理环境（官方 LLM 工具链）

确保你能在 S100P 上通过命令行成功运行官方 LLM Demo（这证明 BPU 环境正常）。

文档：7.4.2 LLM 工具链 | RDK DOC

验证命令：

# 确保已设置 balanced 或 bpu_first 模式
sudo /usr/bin/set_performance_mode.sh
# 运行官方 Demo
./llm_demo --model_path <your_hbm_model_path>

步骤 2：开发 API 桥接服务（核心工作量）

官方工具链提供 C++ SDK，你需要写一个 C++ 或 Python 程序，加载模型并提供 HTTP 接口。

方案 A：C++ 高性能服务（推荐，直接调用 SDK）
基于官方 Demo 代码修改，集成 httplib 或 Crow 库提供 HTTP 服务。

优点：性能最好，直接复用 BPU 推理逻辑，无额外进程开销。
缺点：需要 C++ 开发能力，需处理并发锁（BPU 通常串行推理）。

方案 B：Python 封装（开发快，但需注意性能）
如果官方提供 Python 绑定，可直接调用；若无，需通过 subprocess 调用命令行工具（不推荐，开销大）。

现状：官方工具链主要为 C++，Python 支持需确认具体版本。

简易 C++ Server 思路（伪代码）：

// 1. 初始化 LLM 模型 (BPU)
auto model = llm_sdk::load_model("qwen2.5_3b.hbm");

// 2. 启动 HTTP Server (监听 8080)
server.Post("/v1/chat/completions", [&](const Request& req, Response& res) {
    // 3. 解析 LangChain 发来的 JSON
    auto prompt = parse_json(req.body)["messages"][0]["content"];
    
    // 4. 调用 BPU 推理 (注意加锁，BPU 资源互斥)
    std::lock_guard<std::mutex> lock(g_inference_mutex);
    auto result = model->generate(prompt);
    
    // 5. 返回 OpenAI 格式 JSON
    res.set_content(format_openai_response(result), "application/json");
});
server.listen("0.0.0.0", 8080);

步骤 3：LangChain 连接配置

服务启动后，LangChain 侧配置不变，仅修改 base_url。

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="http://<S100P_IP>:8080/v1", 
    api_key="not-needed", 
    model="rdk-bpu-llm"
)

关键限制与风险

问题	说明	建议
并发能力	BPU 推理通常是串行的，不支持高并发。	API 服务必须加队列/锁，避免多请求同时抢占 BPU 导致崩溃。
显存/内存	3B 模型 + BPU 占用较大，开启 HTTP 服务需预留内存。	确保 ION 内存配置为 `balanced` 或 `bpu_first`，避免 OOM。
开发难度	官方工具链 SDK 文档较少，主要靠 Demo 修改。	建议先跑通 Demo，再逐步剥离推理逻辑到 Server 类中。
hobot_llamacpp 误区	该库的 LLM 部分不吃 BPU 算力（仅视觉吃）。	若你只在乎视觉 BPU，语言 CPU 跑，直接用 `hobot_llamacpp` + 自研 API 更简单。

替代方案（若自研 API 太难）

如果自研 C++ Server 成本过高，可考虑以下折中方案：

方案一：视觉 BPU + 语言 CPU（hobot_llamacpp）
- 优点：代码现成，ROS2 通信成熟，只需写轻量级 HTTP 桥接（如之前提供的 FastAPI 示例）。
- 缺点：LLM 部分不用 BPU，3B 模型首字延迟可能在 1-3 秒左右。
- 适用：对 LLM 推理速度不敏感，主要利用 BPU 做视觉理解。
方案二：云端 API + 本地 BPU 视觉
- 优点：LangChain 直接连云端（如 Kimi/通义），本地 S100P 仅做视觉采集和 BPU 预处理。
- 缺点：依赖网络，数据出域。

建议与社区资源

首选路径：若必须 LLM 上 BPU，请基于 官方 LLM 工具链 Demo 修改，不要基于 hobot_llamacpp（后者 LLM 部分无 BPU 加速）。
发帖求助：官方工具链的 SDK 接口细节（如如何在一个进程中多次调用推理）社区讨论较少。建议你在原帖 34659 下追问：

“请问官方 LLM 工具链是否有 C++ SDK 的头文件示例？我想封装成 HTTP 服务供 LangChain 调用，是否有并发推理的注意事项？”
参考代码：查看 hobot_llamacpp 的源码结构，虽然它 LLM 用 CPU，但其 ROS2 节点封装逻辑 可参考用于理解如何调度推理任务。

需要我帮你梳理官方 LLM 工具链 Demo 的代码结构，以便你修改成 Server 吗？

Marcelo · 2026 年4 月 14 日 02:57

这块需要自己进行二次开发了，我理解只需要替换一下推理部分即可

RDK s100p跑llm大语言模型，可以使用bpu算力吗，可以的话，怎么才能使用上呢

结论

当前可用方案

方案一：使用官方 LLM 工具链（推荐）

方案二：hobot_llamacpp（视觉+BPU，语言+CPU）

重要注意事项

排查路径

建议

结论

实现路径

方案一：使用 llama.cpp Server（推荐，最成熟）

步骤 1：确认模型格式

步骤 2：编译并启动 Server（在 S100P 上）

步骤 3：LangChain 连接（在开发机或板端 Python）

方案二：使用 OpenClaw 作为中间层（社区已有案例）

关键限制与注意事项

推荐文档与资源

下一步建议

结论

实施架构

详细步骤

步骤 1：确认推理环境正常

步骤 2：编写 FastAPI 桥接服务

步骤 3：启动服务

步骤 4：LangChain 调用配置

关键注意事项

进阶优化建议

社区资源

结论

实施架构

详细步骤

步骤 1：确认推理环境（官方 LLM 工具链）

步骤 2：开发 API 桥接服务（核心工作量）

步骤 3：LangChain 连接配置

关键限制与风险

替代方案（若自研 API 太难）

建议与社区资源