rdks100p上运行的模型，怎么适配langchain生态进行开发呢？

sky77777 · 2026 年4 月 13 日 10:13

如果我在rdks100p上部署的模型，我想要兼容langchain框架，也就是初始化出来一个模型，可以适配langchain生态进行开发，需要怎么实现呢，有参考文档吗？
目前是在芯片端使用如下命令
./oellm_run --hbm_path ../../model/DeepSeek_R1_Distill_Qwen_7B_1024.hbm --tokenizer_dir ../../config/DeepSeek_R1_Distill_Qwen_7B_config/ --template_path ../../config/DeepSeek_R1_Distill_Qwen_7B_config/DeepSeek_R1_Distill_Qwen_7B.jinja --model_type 1
这个命令的方式启动，怎么给他进行封装后，可以类似ollama或者云模型一样初始化出来，然后让langchain生态可以使用？

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

结论

目前 RDK S100P 官方工具链尚未直接提供 LangChain 适配层，但可通过 封装 oellm_run 为 HTTP API 服务 实现兼容。核心思路是：用 Python 快速构建一个符合 OpenAI 格式的 API 服务，LangChain 可直接调用。

实现步骤

1. 封装 `oellm_run` 为 HTTP 服务（使用 FastAPI）

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
import subprocess
import json

app = FastAPI()

class ChatRequest(BaseModel):
    messages: list
    model: str = "s100p-local"

@app.post("/v1/chat/completions")
async def chat(req: ChatRequest):
    # 提取用户最后一条消息
    prompt = req.messages[-1]["content"]
    
    # 调用 oellm_run（需根据实际模板调整输入格式）
    cmd = [
        "./oellm_run",
        "--hbm_path", "../../model/DeepSeek_R1_Distill_Qwen_7B_1024.hbm",
        "--tokenizer_dir", "../../config/DeepSeek_R1_Distill_Qwen_7B_config/",
        "--template_path", "../../config/DeepSeek_R1_Distill_Qwen_7B_config/DeepSeek_R1_Distill_Qwen_7B.jinja",
        "--model_type", "1",
        "--prompt", prompt  # 需确认工具链是否支持 --prompt 参数
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    return {
        "choices": [{
            "message": {"role": "assistant", "content": result.stdout}
        }]
    }

2. 启动服务

# 安装依赖
pip install fastapi uvicorn

# 启动服务（监听 0.0.0.0:8000）
uvicorn app:app --host 0.0.0.0 --port 8000

3. LangChain 调用示例

from langchain_community.llms import OpenAI

# 指向本地服务
llm = OpenAI(
    openai_api_base="http://<S100P_IP>:8000/v1",
    model_name="s100p-local",
    openai_api_key="not-needed"  # 本地服务可忽略
)

response = llm.invoke("你好，请介绍下 RDK S100P")
print(response)

关键注意事项

输入格式适配
- 需确认 oellm_run 是否支持 --prompt 参数，若不支持，需通过 stdin 传递输入 或修改工具链源码。
- 参考官方文档：LLM Toolchain
性能优化
- 模型加载耗时较长，建议 服务启动时预加载模型（需修改 oellm_run 为长驻进程模式）。
- 使用 异步队列 处理并发请求（如 Celery + Redis）。
错误处理
- 捕获 oellm_run 的 stderr 输出，返回标准化错误信息。

替代方案（推荐优先尝试）

若官方后续提供 ONNX Runtime 或 Triton 部署支持，可直接通过以下路径集成：

将模型转换为 ONNX 格式（需确认 BPU 是否支持）。
使用 Triton Inference Server 部署，原生支持 LangChain 的 TritonLLM 接口。

社区资源引导

相关讨论：RDK s100p 跑 LLM 大语言模型
工具链文档：LLM Toolchain

建议将封装代码开源到社区，方便后续开发者复用！

Marcelo6151 · 2026 年4 月 14 日 03:04

如小助手回复，目前没有对应案例文档，需要自行二次开发封装一个API了

地瓜小助手_bot · 2026 年4 月 14 日 03:05

补充完善方案

基于搜索结果，目前社区确实没有现成的 LangChain 适配案例，需要自行封装。我帮你把方案细化，特别是解决 oellm_run 的输入传递和长驻进程问题。

方案一：FastAPI + 子进程调用（快速验证）

# app.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import subprocess
import json
import os

app = FastAPI(title="S100P LLM API")

class Message(BaseModel):
    role: str
    content: str

class ChatRequest(BaseModel):
    messages: list[Message]
    model: str = "s100p-local"
    temperature: float = 0.7
    max_tokens: int = 512

class ChatResponse(BaseModel):
    id: str
    object: str = "chat.completion"
    created: int
    model: str
    choices: list

@app.post("/v1/chat/completions")
async def chat(req: ChatRequest):
    try:
        # 提取对话历史，构建 prompt
        prompt = ""
        for msg in req.messages:
            if msg.role == "user":
                prompt += f"User: {msg.content}\n"
            elif msg.role == "assistant":
                prompt += f"Assistant: {msg.content}\n"
        prompt += "Assistant: "
        
        # 调用 oellm_run（通过 stdin 传递 prompt）
        cmd = [
            "./oellm_run",
            "--hbm_path", "../../model/DeepSeek_R1_Distill_Qwen_7B_1024.hbm",
            "--tokenizer_dir", "../../config/DeepSeek_R1_Distill_Qwen_7B_config/",
            "--template_path", "../../config/DeepSeek_R1_Distill_Qwen_7B_config/DeepSeek_R1_Distill_Qwen_7B.jinja",
            "--model_type", "1"
        ]
        
        result = subprocess.run(
            cmd,
            input=prompt,
            capture_output=True,
            text=True,
            timeout=120  # 超时设置
        )
        
        if result.returncode != 0:
            raise HTTPException(status_code=500, detail=result.stderr)
        
        return {
            "id": "chatcmpl-s100p",
            "created": int(subprocess._time.time()),
            "model": req.model,
            "choices": [{
                "index": 0,
                "message": {"role": "assistant", "content": result.stdout.strip()},
                "finish_reason": "stop"
            }]
        }
    except subprocess.TimeoutExpired:
        raise HTTPException(status_code=504, detail="模型推理超时")
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

方案二：长驻进程模式（推荐生产使用）

oellm_run 每次启动都会重新加载模型，耗时严重。建议改为长驻进程 + 管道通信：

# llm_server.py
import subprocess
import threading
import queue
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class LLMWorker:
    def __init__(self):
        self.proc = None
        self.request_queue = queue.Queue()
        self.response_queue = queue.Queue()
        self._start_worker()
    
    def _start_worker(self):
        """启动长驻 oellm_run 进程"""
        cmd = [
            "./oellm_run",
            "--hbm_path", "../../model/DeepSeek_R1_Distill_Qwen_7B_1024.hbm",
            "--tokenizer_dir", "../../config/DeepSeek_R1_Distill_Qwen_7B_config/",
            "--template_path", "../../config/DeepSeek_R1_Distill_Qwen_7B_config/DeepSeek_R1_Distill_Qwen_7B.jinja",
            "--model_type", "1",
            "--interactive"  # 如果支持交互模式
        ]
        
        self.proc = subprocess.Popen(
            cmd,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            bufsize=1
        )
        
        # 启动读取线程
        threading.Thread(target=self._read_output, daemon=True).start()
    
    def _read_output(self):
        while True:
            line = self.proc.stdout.readline()
            if line:
                self.response_queue.put(line.strip())
    
    def infer(self, prompt: str) -> str:
        self.proc.stdin.write(prompt + "\n")
        self.proc.stdin.flush()
        
        # 等待响应（简单实现，生产环境需更完善的协议）
        response = self.response_queue.get(timeout=120)
        return response

# 全局 worker
worker = LLMWorker()

@app.post("/v1/chat/completions")
async def chat(req: ChatRequest):
    prompt = build_prompt(req.messages)
    try:
        response = worker.infer(prompt)
        return build_response(response, req.model)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

关键问题排查清单

问题	排查方法
`oellm_run` 是否支持 `--prompt` 参数	执行 `./oellm_run --help` 查看
是否支持交互模式	尝试 `echo "hello" \| ./oellm_run ...` 测试
模型加载耗时	首次调用记录时间，后续调用对比
并发请求处理	单进程不支持并发，需多进程或队列

LangChain 调用验证

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="http://192.168.1.100:8000/v1",  # S100P 的 IP
    api_key="not-needed",
    model="s100p-local"
)

response = llm.invoke("用一句话介绍 RDK S100P")
print(response.content)

建议行动路径

先验证 oellm_run 的输入方式

./oellm_run --help
echo "你好" | ./oellm_run [其他参数]

用方案一快速搭建 API，验证 LangChain 能否调用
性能达标后，再优化为方案二的长驻模式
将封装代码开源到社区，参考帖子：RDK s100p 跑 LLM 大语言模型

需要我帮你调试 oellm_run 的具体参数吗？可以提供一下 --help 的输出。

sky77777 · 2026 年5 月 7 日 05:35

使用这个芯片的机器人，怎么使用上这个算力的呢，怎么开发相关程序的

地瓜小助手_bot · 2026 年5 月 7 日 05:36

结论

要在 RDK S100P 上使用 BPU 算力开发程序，核心路径是：模型转换 → HBM 部署 → 调用推理。官方提供完整的工具链（OE 工具包），支持视觉和 LLM 模型。

快速入门路径

环境准备

宿主机要求：

Ubuntu 20.04/22.04
OE 工具链版本需与板端系统匹配（执行 cat /etc/version 查看板子版本）

版本匹配参考：

板端系统版本	OE 工具链版本
4.0.2-Beta	OE 3.7.x
4.0.5	OE 3.7.x

下载工具链：

# LLM 工具链（大模型）
wget https://d-robotics-aitoolchain.oss-cn-beijing.aliyuncs.com/llm_s100/1.0.0/D-Robotics_LLM_S100_1.0.0_SDK.tar.gz

# 视觉模型工具链（YOLO 等）
# 参考官方文档获取最新链接

模型转换流程（以 LLM 为例）

# 1. 准备原始模型（HuggingFace 格式）
git clone https://huggingface.co/Qwen/Qwen2.5-3B

# 2. 转换为 HBM 格式（BPU 可执行）
cd D-Robotics_LLM_S100_1.0.0_SDK
python -m hb_llm_convert \
    --model_path ./Qwen2.5-3B \
    --output_path ./qwen2.5_3b.hbm \
    --calib_data ./calib.txt \
    --quant_type w8a8  # 或 w8a16

# 3. 生成配置文件
python -m hb_llm_config \
    --model_type qwen \
    --config_dir ./qwen_config

板端部署运行

传输文件到 S100P：

scp qwen2.5_3b.hbm root@192.168.1.100:/root/model/
scp -r qwen_config/ root@192.168.1.100:/root/config/

运行推理：

# SSH 登录板子
ssh root@192.168.1.100

# 执行推理（你之前用的命令）
./oellm_run \
    --hbm_path ./model/qwen2.5_3b.hbm \
    --tokenizer_dir ./config/qwen_config/ \
    --template_path ./config/qwen_config/qwen.jinja \
    --model_type 1

开发应用程序

方案 A：直接调用 `oellm_run`（简单场景）

import subprocess

def run_inference(prompt: str) -> str:
    cmd = [
        "./oellm_run",
        "--hbm_path", "./model/qwen2.5_3b.hbm",
        "--tokenizer_dir", "./config/qwen_config/",
        "--template_path", "./config/qwen_config/qwen.jinja",
        "--model_type", "1"
    ]
    result = subprocess.run(cmd, input=prompt, capture_output=True, text=True)
    return result.stdout

方案 B：封装为 API 服务（推荐，支持 LangChain）

参考你之前帖子的方案，用 FastAPI 封装：

# 完整代码见：https://forum.d-robotics.cc/t/topic/34709/4
uvicorn app:app --host 0.0.0.0 --port 8000

方案 C：C++ 原生调用（高性能场景）

#include "hrt/hrt.h"

// 加载模型
hrt::Model model = hrt::load_model("qwen2.5_3b.hbm");

// 执行推理
auto output = model.forward(input_tensor);

关键资源

资源类型	链接
官方 LLM 工具链文档	LLM Toolchain
视觉模型部署教程	万字长文：RDKS100 模型量化及部署
BPU 算力使用讨论	RDK s100p 跑 LLM 大语言模型
示例代码	`/app/cdev_demo/bpu`（板端自带）

常见问题排查

问题	解决方案
`BPU IOMMU MAP failed`	设置内存模式：`echo balanced > /sys/class/bpu/bpu0/memory_mode`
工具链版本不匹配	升级板端系统或降级 OE 工具链
算子不支持（如 isnan）	修改模型结构或用等价算子替换
模型加载慢	使用长驻进程模式，避免重复加载

建议行动

先跑通官方示例：板端 /app/cdev_demo/ 下有 BPU 示例
转换一个简单模型：从 Qwen2.5-3B 开始，避免太大模型
封装 API 服务：方便后续 LangChain 集成
沉淀到社区：将你的封装代码发到 Model Zoo 板块

需要我帮你查具体模型的转换参数吗？告诉我你要部署的模型名称。

sky77777 · 2026 年5 月 7 日 05:38

我的意思是实现具体的功能，比如智能体的思考这种，你提供的只是基础的问答对话

地瓜小助手_bot · 2026 年5 月 7 日 05:39

结论

要实现智能体思考与工具调用（不仅仅是问答），需要在 API 服务层之上增加 LangChain Agent 框架，核心是：封装工具函数 + 配置 Agent 执行逻辑。

智能体架构设计

┌─────────────────────────────────────────────────────────┐
│ LangChain Agent (PC/服务器)                              │
│  - ReAct/Function Calling 模式                            │
│  - 工具注册：天气查询、机器人控制、文件搜索等               │
│  - 多轮对话记忆（ConversationBufferMemory）               │
└────────────────────┬────────────────────────────────────┘
                     │ HTTP (OpenAI API)
                     ▼
┌─────────────────────────────────────────────────────────┐
│ FastAPI 桥接服务 (RDK S100P)                             │
│  - 接收 LLM 推理请求                                      │
│  - 转发给 BPU 推理引擎                                    │
│  - 返回生成结果                                          │
└────────────────────┬────────────────────────────────────┘
                     │ C++ SDK / 命令行
                     ▼
┌─────────────────────────────────────────────────────────┐
│ 官方 LLM 工具链 (BPU 加速)                                │
│  - Qwen2.5-3B HBM 模型                                   │
│  - BPU 推理加速                                          │
└─────────────────────────────────────────────────────────┘

实现步骤

先确保 API 服务正常（基础层）

参考之前帖子的 FastAPI 封装代码，确保 LangChain 能调用 S100P 的 BPU 模型：

# s100p_llm_api.py (板端运行)
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import subprocess

app = FastAPI()

class ChatRequest(BaseModel):
    messages: list
    model: str = "s100p-bpu"

@app.post("/v1/chat/completions")
async def chat(req: ChatRequest):
    # 构建 prompt（根据你的模板调整）
    prompt = ""
    for msg in req.messages:
        prompt += f"{msg['role']}: {msg['content']}\n"
    
    # 调用 oellm_run（或 C++ SDK）
    cmd = [
        "./oellm_run",
        "--hbm_path", "./model/qwen2.5_3b.hbm",
        "--tokenizer_dir", "./config/",
        "--template_path", "./config/qwen.jinja",
        "--model_type", "1"
    ]
    
    result = subprocess.run(cmd, input=prompt, capture_output=True, text=True, timeout=120)
    
    return {
        "choices": [{"message": {"role": "assistant", "content": result.stdout}}]
    }

启动服务：

uvicorn s100p_llm_api:app --host 0.0.0.0 --port 8000

开发端：LangChain Agent 配置（核心）

在**开发机（PC/服务器）**上编写 Agent 代码，注册工具函数：

# agent_demo.py (开发机运行)
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, Tool, AgentType
from langchain.memory import ConversationBufferMemory
import requests

# === 1. 定义工具函数 ===

def search_weather(city: str) -> str:
    """查询指定城市的天气"""
    # 这里可以调用真实天气 API
    return f"{city} 今天晴朗，温度 25°C"

def control_robot(action: str) -> str:
    """控制机器人执行动作（前进、后退、转向等）"""
    # 通过 ROS2/HTTP 控制机器人
    # requests.post("http://192.168.1.100:5000/control", json={"action": action})
    return f"机器人已执行：{action}"

def file_search(query: str) -> str:
    """搜索本地文档"""
    # 可以用 RAG 检索本地知识库
    return f"找到相关文档：{query}"

# === 2. 注册工具 ===
tools = [
    Tool(
        name="Weather",
        func=search_weather,
        description="查询城市天气，输入格式：城市名"
    ),
    Tool(
        name="RobotControl",
        func=control_robot,
        description="控制机器人动作，输入格式：动作名称（前进/后退/左转/右转）"
    ),
    Tool(
        name="FileSearch",
        func=file_search,
        description="搜索本地文档，输入格式：搜索关键词"
    ),
]

# === 3. 连接 S100P 的 API 服务 ===
llm = ChatOpenAI(
    base_url="http://192.168.1.100:8000/v1",  # S100P 的 IP
    api_key="not-needed",
    model="s100p-bpu",
    temperature=0.7
)

# === 4. 初始化 Agent（带记忆） ===
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,  # ReAct 模式
    memory=memory,
    verbose=True  # 打印思考过程
)

# === 5. 测试智能体 ===
if __name__ == "__main__":
    # 测试 1：工具调用
    response = agent.run("北京今天天气怎么样？")
    print(f"回答：{response}")
    
    # 测试 2：多轮对话 + 工具调用
    response = agent.run("我想让机器人前进，然后查询一下上海天气")
    print(f"回答：{response}")
    
    # 测试 3：纯对话（无需工具）
    response = agent.run("介绍一下你自己")
    print(f"回答：{response}")

智能体思考过程示例

当用户问：“北京今天天气怎么样？然后让机器人前进”

Agent 会输出以下思考过程（verbose=True 时可见）：

> Entering new AgentExecutor chain...
Thought: 我需要先查询北京的天气，然后控制机器人前进
Action: Weather
Action Input: 北京
Observation: 北京 今天晴朗，温度 25°C
Thought: 天气查询完成，现在需要控制机器人
Action: RobotControl
Action Input: 前进
Observation: 机器人已执行：前进
Thought: 所有任务完成
Final Answer: 北京今天晴朗，温度 25°C。机器人已经前进。
> Finished chain.

关键功能扩展

1. 多模态智能体（视觉 + 语言）

如果要用 BPU 做视觉理解，再交给 LLM 决策：

def analyze_image(image_path: str) -> str:
    """分析图片内容（调用 BPU 视觉模型）"""
    # 1. 调用 BPU 视觉模型（YOLO/关键点检测等）
    # 2. 返回检测结果描述
    return "图片中检测到一个人，距离 2 米"

tools.append(Tool(
    name="ImageAnalysis",
    func=analyze_image,
    description="分析图片内容，输入格式：图片路径"
))

2. RAG 知识库增强

from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings

# 加载本地知识库
embeddings = HuggingFaceEmbeddings(model_name="shibing624/text2vec-base-chinese")
vectorstore = FAISS.load_local("./knowledge_base", embeddings)

tools.append(Tool(
    name="KnowledgeBase",
    func=vectorstore.similarity_search,
    description="检索本地知识库，输入格式：问题关键词"
))

3. 流式输出（打字机效果）

修改 FastAPI 支持 SSE 流式传输：

from fastapi.responses import StreamingResponse

@app.post("/v1/chat/completions/stream")
async def chat_stream(req: ChatRequest):
    def generate():
        # 逐字返回推理结果
        for token in run_inference_streaming(req.messages):
            yield f"data: {token}\n\n"
    
    return StreamingResponse(generate(), media_type="text/event-stream")

常见问题排查

问题	解决方案
Agent 不调用工具	检查 `Tool` 的 `description` 是否清晰，ReAct 模式需要明确描述
工具调用死循环	设置 `max_iterations=5` 限制最大尝试次数
BPU 推理慢影响体验	使用量化模型（w8a8），或异步执行工具调用
多轮对话丢失上下文	确保 `ConversationBufferMemory` 正确传递

建议行动路径

先跑通基础 API：确保 LangChain 能调用 S100P 的 BPU 模型
添加 1-2 个简单工具：如天气查询、文件搜索
测试 ReAct 模式：观察 Agent 思考过程
扩展多模态能力：集成 BPU 视觉模型作为工具
沉淀到社区：将完整代码发到 Model Zoo 板块

社区资源

LangChain Agent 文档：LangChain overview - Docs by LangChain
ReAct 模式详解：agents | langchain | LangChain Reference
相关讨论：RDK s100p 跑 LLM 大语言模型

需要我帮你写一个完整的可运行 Demo（包含 API 服务 + Agent 代码）吗？可以打包成 GitHub 仓库方便复用。

sky77777 · 2026 年5 月 7 日 05:44

二次开发封装，有参考资料吗

地瓜小助手_bot · 2026 年5 月 7 日 05:45

结论

目前社区没有现成的“一键封装包”，但有完整的参考代码和开发路径。你需要基于官方 LLM 工具链的 Demo 进行二次开发。

核心参考资料如下：

关键参考资料

1. 官方 LLM 工具链 Demo（最核心）

这是你二次开发的起点，所有封装都基于此代码修改：

资源	说明
SDK 下载	`D-Robotics_LLM_S100_1.0.0_SDK.tar.gz`
Demo 位置	解压后在 `samples/` 或 `demo/` 目录下
核心文件	`llm_demo.cpp` 或 `oellm_run` 源码
文档	LLM Toolchain 官方文档

获取方式：

# 下载工具链
wget https://d-robotics-aitoolchain.oss-cn-beijing.aliyuncs.com/llm_s100/1.0.0/D-Robotics_LLM_S100_1.0.0_SDK.tar.gz

# 解压查看 Demo 代码
tar -xzf D-Robotics_LLM_S100_1.0.0_SDK.tar.gz
cd D-Robotics_LLM_S100_1.0.0_SDK
find . -name "*.cpp" | head -20  # 查找 C++ 示例

2. 社区已有封装案例（参考架构）

虽然没直接封装 LLM，但以下帖子的架构思路可复用：

帖子	可参考点
hobot_llamacpp ROS2 封装	学习如何将推理逻辑封装为可调用接口
OpenClaw 在 RDK 部署	AI 网关如何代理本地模型 API
RDKS100 模型量化及部署	完整的模型转换 + 部署流程

二次开发路径（3 种方案）

方案 A：修改官方 Demo 添加 HTTP 服务（推荐，性能最好）

步骤：

找到官方 Demo 的推理核心代码（通常是 llm_demo.cpp）
集成轻量级 HTTP 库（如 httplib.h 或 Crow）
将推理逻辑封装为 HTTP 回调函数

代码框架：

// main.cpp (基于官方 Demo 修改)
#include "httplib.h"
#include "llm_sdk.h"  // 官方 SDK 头文件

// 全局模型实例（避免重复加载）
std::shared_ptr<llm::Model> g_model;

int main() {
    // 1. 初始化模型（BPU 加载）
    g_model = llm::load_model("./model/qwen2.5_3b.hbm");
    
    // 2. 启动 HTTP Server
    httplib::Server svr;
    
    svr.Post("/v1/chat/completions", [](const httplib::Request& req, httplib::Response& res) {
        // 3. 解析 LangChain 请求
        auto json_body = parse_json(req.body);
        std::string prompt = extract_prompt(json_body);
        
        // 4. 调用 BPU 推理（注意加锁）
        static std::mutex g_mutex;
        std::lock_guard<std::mutex> lock(g_mutex);
        std::string result = g_model->generate(prompt);
        
        // 5. 返回 OpenAI 格式
        res.set_content(build_openai_response(result), "application/json");
    });
    
    // 6. 监听端口
    svr.listen("0.0.0.0", 8080);
    return 0;
}

编译：

# 需要链接官方 SDK 库
g++ -std=c++17 main.cpp -o llm_server \
    -I./include -L./lib -lllm_sdk -lhttplib \
    -pthread

方案 B：Python FastAPI + subprocess 调用（开发最快）

适合快速验证，但性能略低（每次启动进程）：

# llm_api_server.py
from fastapi import FastAPI
import subprocess
import json

app = FastAPI()

@app.post("/v1/chat/completions")
async def chat(request: dict):
    prompt = request["messages"][-1]["content"]
    
    # 调用官方命令行工具
    cmd = [
        "./oellm_run",
        "--hbm_path", "./model/qwen2.5_3b.hbm",
        "--tokenizer_dir", "./config/",
        "--template_path", "./config/qwen.jinja",
        "--model_type", "1"
    ]
    
    result = subprocess.run(cmd, input=prompt, capture_output=True, text=True, timeout=120)
    
    return {
        "choices": [{"message": {"role": "assistant", "content": result.stdout}}]
    }

启动：

pip install fastapi uvicorn
uvicorn llm_api_server:app --host 0.0.0.0 --port 8000

方案 C：C++ 长驻进程 + Python 桥接（平衡方案）

思路：C++ 长驻加载模型，Python 通过管道/共享内存通信：

┌──────────────┐   管道/Socket   ┌──────────────┐
│ Python API   │ ◄─────────────► │ C++ 推理进程 │
│ (FastAPI)    │                 │ (BPU 加载)    │
└──────────────┘                 └──────────────┘

优势：

模型只加载一次（C++ 长驻）
Python 层灵活处理 HTTP 协议
性能优于纯 subprocess 方案

完整 Demo 仓库（我可帮你创建）

如果你需要，我可以帮你创建一个GitHub 风格的完整 Demo 仓库，包含：

C++ 服务代码（基于官方 Demo 修改）
Python FastAPI 桥接（快速验证版）
LangChain Agent 示例（带工具调用）
Dockerfile（一键部署）
编译脚本（自动链接 SDK）

需要我现在创建这个 Demo 仓库吗？ 创建后你可以直接在此基础上修改。

关键注意事项

问题	解决方案
SDK 头文件在哪	解压 SDK 后在 `include/` 目录，如 `hrt/hrt.h`
并发推理	BPU 通常串行，API 服务必须加锁
内存配置	确保 `balanced` 模式，避免 OOM
文档缺失	直接参考 `llm_demo.cpp` 的调用逻辑

建议行动

先下载 SDK，查看 samples/ 下的 Demo 代码
跑通官方 Demo，确认 BPU 推理正常
选择方案：
- 想快速验证 → 方案 B（Python）
- 想生产部署 → 方案 A（C++）
发帖跟进：在原帖追问 SDK 接口细节

需要我帮你创建完整的 Demo 代码仓库吗？包含 C++ 和 Python 两个版本。

Marcelo6151 · 2026 年5 月 7 日 07:11

算力使用主要表现为模型推理能力可以参考model zoo或者算法工具链手册来推理自己的模型

大模型这块使用方式主要为提供的LLM手册，开源可以自己二次开发，目前没有别的参考资料，已经有提供最基础的模型的runtime方案。

rdks100p上运行的模型，怎么适配langchain生态进行开发呢？

结论

实现步骤

1. 封装 oellm_run 为 HTTP 服务（使用 FastAPI）

2. 启动服务

3. LangChain 调用示例

关键注意事项

替代方案（推荐优先尝试）

社区资源引导

补充完善方案

方案一：FastAPI + 子进程调用（快速验证）

方案二：长驻进程模式（推荐生产使用）

关键问题排查清单

LangChain 调用验证

建议行动路径

结论

快速入门路径

环境准备

模型转换流程（以 LLM 为例）

板端部署运行

开发应用程序

方案 A：直接调用 oellm_run（简单场景）

方案 B：封装为 API 服务（推荐，支持 LangChain）

方案 C：C++ 原生调用（高性能场景）

关键资源

常见问题排查

建议行动

结论

智能体架构设计

实现步骤

先确保 API 服务正常（基础层）

开发端：LangChain Agent 配置（核心）

智能体思考过程示例

关键功能扩展

1. 多模态智能体（视觉 + 语言）

2. RAG 知识库增强

3. 流式输出（打字机效果）

常见问题排查

建议行动路径

社区资源

结论

关键参考资料

1. 官方 LLM 工具链 Demo（最核心）

2. 社区已有封装案例（参考架构）

二次开发路径（3 种方案）

方案 A：修改官方 Demo 添加 HTTP 服务（推荐，性能最好）

方案 B：Python FastAPI + subprocess 调用（开发最快）

方案 C：C++ 长驻进程 + Python 桥接（平衡方案）

完整 Demo 仓库（我可帮你创建）

关键注意事项

建议行动

1. 封装 `oellm_run` 为 HTTP 服务（使用 FastAPI）

方案 A：直接调用 `oellm_run`（简单场景）