Go + Ollama 在本地构建你的 RAG 应用

最新推荐文章于 2025-04-28 08:30:00 发布

AI程序猿人

最新推荐文章于 2025-04-28 08:30:00 发布

阅读量1.8k

点赞数 13

文章标签： golang 开发语言人工智能大模型 RAG 大模型应用 ollama

本文链接：https://blog.csdn.net/python1222_/article/details/144348625

版权

这篇文章会引导大家使用 Golang 设置本地大型语言模型 (LLM) 并与之交互，以此在本地构建你的 AI 应用。

设置本地 LLM

首先，我们需要在本地计算机上运行 LLM。为此，我们将使用 Ollama（可在GitHub ollama[1] 上获取）。虽然本地加载模型有多种选择，但我发现 Ollama 是相对容易使用的。Ollama 支持 macOS、Linux 和 Windows。本文的代码还没有在 Windows 上测试过，所以我这里重点介绍 macOS 和 Linux，但在 Windows 上的过程应该类似。

从官方网站下载并安装 Ollama

接下来，在操作系统上打开终端，选择要运行的模型。最简单的方法是从 Ollama 模型列表中选择一个模型。你还可以从 Hugging Face 等资源中安装其他模型。选定模型后，在终端运行以下命令：

ollama pull <model name>

或者

ollama run <model name>

然后我们可以在本地计算机上运行 LLM 了。

使用 Go 与 LLM 交互

假设你已经建立了 Go 环境（如果没有，参考 Go 安装说明），然后我们就可以开始写代码了。

1. 初始化项目

mkdir go-ollama
cd go-ollama
go mod init go-ollama

2. 编辑代码

用你喜欢的编辑器打开一个新文件 main.go。首先根据 Ollama API 文档定义聊天请求结构：

package main

type Request struct {
 Model    string    `json:"model"`
 Messages []Message `json:"messages"`
 Stream   bool      `json:"stream"`
}

type Message struct {
 Role    string `json:"role"`
 Content string `json:"content"`
}

参数的含义分别是：

Model: 使用 Ollama 下载的模型, 这里是 llama3.1
Stream: 决定接收恒定的响应流（设为 true）还是单个响应（设为 false）。本例中我们将使用 false
Message 结构：该结构包含要发送给 AI 的问题。

package main

type ChatRequest struct {
 Model    string    `json:"model"`
 Messages []Message `json:"messages"`
 Stream   bool      `json:"stream"`
}

type Message struct {
 Role    string `json:"role"`
 Content string `json:"content"`
}

func main() {
 msg := Message{
  Role:    "user",
  Content: "Why is the sky blue?",
 }
 req := Request{
  Model:    "llama3.1",
  Stream:   false,
  Messages: []Message{msg},
 }
}

3. 发送请求和接收回复

接下来，让我们向 Ollama 发送此请求并获取响应。下面是基于文档的响应结构：

package main

import "time"

type Response struct {
 Model              string    `json:"model"`
 CreatedAt          time.Time `json:"created_at"`
 Message            Message   `json:"message"`
 Done               bool      `json:"done"`
 TotalDuration      int64     `json:"total_duration"`
 LoadDuration       int       `json:"load_duration"`
 PromptEvalCount    int       `json:"prompt_eval_count"`
 PromptEvalDuration int       `json:"prompt_eval_duration"`
 EvalCount          int       `json:"eval_count"`
 EvalDuration       int64     `json:"eval_duration"`
}

让我们使用 Go 的标准库创建一个简单的 HTTP 客户端：

func talkToOllama(url string, ollamaReq Request) (*Response, error) {
 js, err := json.Marshal(&ollamaReq)
 if err != nil {
  return nil, err
 }
 client := http.Client{}
 httpReq, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(js))
 if err != nil {
  return nil, err
 }
 httpResp, err := client.Do(httpReq)
 if err != nil {
  return nil, err
 }
 defer httpResp.Body.Close()
 ollamaResp := Response{}
 err = json.NewDecoder(httpResp.Body).Decode(&ollamaResp)
 return &ollamaResp, err
}

TalkToOllama: 该函数接收 Ollama API URL 和请求结构。
JSON Marshaling：将请求结构转换为 JSON 格式。
HTTP 请求：创建并发送带有 JSON 有效载荷的 POST 请求。
响应处理：将 JSON 解码为响应结构并返回。

4. 运行程序

下面是完整的代码：

package main

import (
 "bytes"
 "encoding/json"
 "fmt"
 "net/http"
 "os"
 "time"
)

type Request struct {
 Model    string    `json:"model"`
 Messages []Message `json:"messages"`
 Stream   bool      `json:"stream"`
}

type Message struct {
 Role    string `json:"role"`
 Content string `json:"content"`
}

type Response struct {
 Model              string    `json:"model"`
 CreatedAt          time.Time `json:"created_at"`
 Message            Message   `json:"message"`
 Done               bool      `json:"done"`
 TotalDuration      int64     `json:"total_duration"`
 LoadDuration       int       `json:"load_duration"`
 PromptEvalCount    int       `json:"prompt_eval_count"`
 PromptEvalDuration int       `json:"prompt_eval_duration"`
 EvalCount          int       `json:"eval_count"`
 EvalDuration       int64     `json:"eval_duration"`
}

const defaultOllamaURL = "http://localhost:11434/api/chat"

func main() {
 start := time.Now()
 msg := Message{
  Role:    "user",
  Content: "Why is the sky blue?",
 }
 req := Request{
  Model:    "llama3.1",
  Stream:   false,
  Messages: []Message{msg},
 }
 resp, err := talkToOllama(defaultOllamaURL, req)
 if err != nil {
  fmt.Println(err)
  os.Exit(1)
 }
 fmt.Println(resp.Message.Content)
 fmt.Printf("Completed in %v", time.Since(start))
}

func talkToOllama(url string, ollamaReq Request) (*Response, error) {
 js, err := json.Marshal(&ollamaReq)
 if err != nil {
  return nil, err
 }
 client := http.Client{}
 httpReq, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(js))
 if err != nil {
  return nil, err
 }
 httpResp, err := client.Do(httpReq)
 if err != nil {
  return nil, err
 }
 defer httpResp.Body.Close()
 ollamaResp := Response{}
 err = json.NewDecoder(httpResp.Body).Decode(&ollamaResp)
 return &ollamaResp, err
}

go run main.go

运行后应该会看到与此类似的响应：

The sky appears blue to us because of a phenomenon called scattering, which occurs when sunlight interacts with the tiny molecules of gases in the atmosphere. Here's a simplified explanation:

1. Sunlight enters the Earth's atmosphere**: When sunlight enters our atmosphere, it consists of a broad spectrum of electromagnetic radiation, including all the colors of the visible light (red, orange, yellow, green, blue, indigo, and violet).
2. Scattering occurs**: As sunlight travels through the atmosphere, it encounters tiny molecules of gases such as nitrogen (N2) and oxygen (O2). These molecules are much smaller than the wavelength of light, so they scatter the shorter (blue) wavelengths more efficiently than the longer (red) wavelengths.
3. Blue light is scattered in all directions**: The scattering process favors blue light because it has a shorter wavelength, which allows it to be deflected by the gas molecules more easily. This scattered blue light reaches our eyes from all parts of the sky.
4. Our eyes perceive the sky as blue**: Since we see the scattered blue light from every direction in the atmosphere, our brains interpret this as a blue color for the entire sky.

Other factors can affect the apparent color of the sky, such as:

* Dust and pollutants**: Tiny particles in the air can scatter light in a way that adds a reddish tint to the sky.
* Clouds: When sunlight passes through water droplets or ice crystals in clouds, it scatters in all directions, giving the sky a white or gray appearance.
* Time of day: The angle of the sun changes throughout the day, which can alter the intensity and color of the scattered light. For example, during sunrise and sunset, the light has to travel through more of the Earth's atmosphere, scattering off more particles and making the sky appear redder.

In summary, the sky appears blue due to the scattering of sunlight by the tiny molecules in the atmosphere, which favors shorter wavelengths like blue light.
Completed in 38.315152042s