【AMD ROCm 实战】AMD ROCm + Spring Boot + Spring AI：AMD GPU 加速的本地大模型应用全链路实战

# Step1: 添加ROCm仓库
sudo apt update
wget https://repo.radeon.com/amdgpu-install/latest/ubuntu/noble/amdgpu-install_*.deb
sudo apt install ./amdgpu-install_*.deb
# Step2: 安装ROCm
sudo amdgpu-install --usecase=rocm
# Step3: 添加用户到渲染组（否则无权限访问GPU）
sudo usermod -aG render,video {spring-ai.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

spring:
  ai:
    ollama:
      # Ollama服务地址（本地部署）
      base-url: http://localhost:11434
      chat:
        model: qwen2.5:7b
        options:
          temperature: 0.7
          top-p: 0.9
          num-predict: 2048      # 最大生成Token数
      embedding:
        model: bge-m3
        options:
          dimensions: 1024
  # PGVector向量库配置
  datasource:
    url: jdbc:postgresql://localhost:5432/ai_knowledge
    username: postgres
    password: your_password

@Service
@Slf4j
public class ChatService {
    private final ChatClient chatClient;
    public ChatService(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder
                .defaultSystem("你是一个专业的金融分析师助手，用中文回答问题。" +
                               "回答要准确、专业，引用具体数据。")
                .build();
    }
    /**
     * 单轮对话
     */
    public String chat(String userMessage) {
        return chatClient.prompt()
                .user(userMessage)
                .call()
                .content();
    }
    /**
     * 流式对话（SSE推送，用户无需等待完整回答）
     */
    public Flux<String> chatStream(String userMessage) {
        return chatClient.prompt()
                .user(userMessage)
                .stream()
                .content();
    }
}

@RestController
@RequestMapping("/api/chat")
public class ChatController {
    @Autowired
    private ChatService chatService;
    /**
     * 同步对话
     */
    @PostMapping
    public ResponseEntity<Map<String, String>> chat(
            @RequestBody Map<String, String> request) {
        String answer = chatService.chat(request.get("message"));
        return ResponseEntity.ok(Map.of("answer", answer));
    }
    /**
     * 流式对话（SSE）
     */
    @GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chatStream(@RequestParam String message) {
        return chatService.chatStream(message);
    }
}

@Service
@Slf4j
public class RagService {
    private final ChatClient chatClient;
    private final VectorStore vectorStore;
    private final EmbeddingModel embeddingModel;
    public RagService(ChatClient.Builder chatClientBuilder,
                      VectorStore vectorStore,
                      EmbeddingModel embeddingModel) {
        this.chatClient = chatClientBuilder.build();
        this.vectorStore = vectorStore;
        this.embeddingModel = embeddingModel;
    }
    /**
     * 导入文档到向量库
     */
    public void importDocument(String content, Map<String, Object> metadata) {
        // 文本分片
        List<Document> documents = List.of(
            new Document(content, metadata)
        );
        // 自动向量化并存入PGVector
        vectorStore.add(documents);
        log.info("文档导入成功, metadata={}", metadata);
    }
    /**
     * RAG问答：检索相关文档 + 生成回答
     */
    public String ask(String question) {
        // 1. 从向量库检索相关文档（Top 5）
        List<Document> relevantDocs = vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(question)
                .topK(5)
                .similarityThreshold(0.7)
                .build()
        );
        // 2. 拼接检索到的文档内容
        String context = relevantDocs.stream()
                .map(Document::getText)
                .collect(Collectors.joining("\n\n"));
        // 3. 基于检索结果生成回答
        return chatClient.prompt()
                .system("基于以下参考资料回答用户问题。如果资料中没有相关信息，" +
                        "请说明，不要编造答案。\n\n参考资料：\n{context}")
                .user(question)
                .variables(Map.of("context", context))
                .call()
                .content();
    }
}

@Configuration
public class FunctionConfig {
    /**
     * 注册一个查询股票行情的函数
     * 模型会根据用户问题自动决定是否调用
     */
    @Bean
    @Description("查询指定股票代码的最新行情信息，包括当前价格、涨跌幅、成交量")
    public Function<StockRequest, StockResponse> stockQuery() {
        return request -> {
            // 实际业务中调用行情API
            StockResponse response = new StockResponse();
            response.setCode(request.code());
            response.setPrice(125.80);
            response.setChangePercent(-1.23);
            response.setVolume(15680000L);
            return response;
        };
    }
    public record StockRequest(
        @Description("股票代码，如 600519") String code
    ) {}
    @Data
    public static class StockResponse {
        private String code;
        private double price;
        private double changePercent;
        private long volume;
    }
}

@Service
public class SmartChatService {
    private final ChatClient chatClient;
    public SmartChatService(ChatClient.Builder builder) {
        this.chatClient = builder
                .defaultFunctions("stockQuery")  // 注册函数
                .build();
    }
    public String chat(String message) {
        // 用户问："贵州茅台今天涨了吗？"
        // 模型会自动调用 stockQuery("600519")，然后基于结果回答
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}

# 拉取72B量化模型
ollama pull qwen2.5:72b
# 运行（Ollama自动识别UMA，混合加载）
ollama run qwen2.5:72b --verbose
# --verbose 输出示例：
# loaded 72B model
# GPU offload layers: 40/80 (UMA partial offload)
# GPU memory: 58GB / 64GB
# CPU memory: 22GB
# eval speed: 4.2 tok/s

# 查看所有GPU
rocm-smi
# 期望输出：
# GPU[0]: AMD Radeon RX 7900 XTX (gfx1100) 24GB
# GPU[1]: AMD Radeon RX 7900 XTX (gfx1100) 24GB
# 指定使用的GPU（逗号分隔）
export ROCR_VISIBLE_DEVICES=0,1
# Ollama自动将模型分配到多张GPU
ollama run qwen2.5:32b --verbose
# 输出: GPU offload layers: 60/60 (split across 2 GPUs)

# docker-compose.yml
services:
  ollama-1:
    image: ollama/ollama:rocm
    devices:
      - /dev/dri/renderD128    # GPU 0
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
  ollama-2:
    image: ollama/ollama:rocm
    devices:
      - /dev/dri/renderD129    # GPU 1
    ports:
      - "11435:11434"
    volumes:
      - ollama_data:/root/.ollama
volumes:
  ollama_data:

spring:
  ai:
    ollama:
      # 多实例时，通过Nginx代理
      base-url: http://ollama-lb:11434

upstream ollama_cluster {
    least_conn;
    server 127.0.0.1:11434;
    server 127.0.0.1:11435;
}
server {
    listen 11434;
    location / {
        proxy_pass http://ollama_cluster;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }
}

# 添加用户到render组
sudo usermod -aG render,video $LOGNAME
# 重新登录（关键！组变更需要重新登录生效）
logout
# 验证GPU权限
ls -la /dev/dri/renderD*
# 期望: crw-rw---- render组可读写
# 重启Ollama
systemctl restart ollama

# ✅ 正确格式
export HSA_OVERRIDE_GFX_VERSION=10.3.0   # gfx1030 (RDNA2)
# ❌ 错误格式
export HSA_OVERRIDE_GFX_VERSION=1030     # 缺少点号
export HSA_OVERRIDE_GFX_VERSION=11.0.0   # RDNA3的gfx1100不能这样设

@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> chatStream(@RequestParam String message) {
    return chatService.chatStream(message)
            .map(chunk -> ServerSentEvent.<String>builder()
                    .data(chunk)
                    .build());
}

-- 创建向量表时指定正确维度
CREATE TABLE vector_store (
    id UUID PRIMARY KEY,
    content TEXT,
    metadata JSONB,
    embedding VECTOR(1024)   -- BGE-M3 输出1024维
);

spring:
  ai:
    ollama:
      embedding:
        options:
          dimensions: 1024    # 必须与向量表维度一致

# 设置Ollama使用CPU补充加载
export OLLAMA_NUM_GPU=40    # 只将40层放到GPU，其余CPU处理
# 需要足够的系统内存（至少64GB）
# 24GB GPU + 40GB CPU内存 ≈ 64GB 总需求
# 查看系统可用内存
free -h

你的显存是多少？
├── 8GB（RX 7600）
│   └── Qwen2.5-7B Q4_K_M（4.5GB）
├── 16GB（RX 7800 XT）
│   └── Qwen2.5-14B Q4_K_M（8.5GB）
├── 24GB（RX 7900 XTX）
│   └── Qwen2.5-32B Q4_K_M（18GB）
├── 32GB（Radeon PRO W7800）
│   └── Qwen2.5-32B Q5_K_M（22GB）
├── 64GB+ UMA（Ryzen AI Max+）
│   └── Qwen2.5-72B Q4_K_M（混合加载）
└── 192GB（MI300X）
    └── Qwen2.5-72B Q8_0（全精度）