ollama搭建本地ai大模型并应用调用

1、下载ollama

1）https://ollama.com 进入网址，点击download下载

2）下载后直接安装即可。

2、启动配置模型

默认是启动cmd窗口直接输入

复制代码

1 ollama run llama3

复制代码

启动llama3大模型或者启动千问大模型

复制代码

1 ollama run qwen2

复制代码

启动输入你需要输入的问题即可

3、配置UI界面

安装docker

并部署web操作界面

复制代码

1 docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui --restart always ghcr.io/open-webui/open-webui:main

安装完毕后，安装包较大，需等待一段时间。

localhost:3000即可打开网址

4、搭建本地知识库

AnythingLLM

5、配置文件

开发11434端口，便于外部访问接口，如果跨域访问的话配置OLLAMA_ORIGINS=*

Windows版

只需要在系统环境变量中直接配置,
OLLAMA_HOST为变量名，"0.0.0.0:11434"为变量值

复制代码

1 OLLAMA_HOST= "0.0.0.0:11434"

MAC版

配置OLLAMA_HOST

复制代码

1 sudo sh -c 'echo "export OLLAMA_HOST=0.0.0.0:11434">>/etc/profile'launchctl setenv OLLAMA_HOST "0.0.0.0:11434"

Linux版

配置OLLAMA_HOST

复制代码

1 Environment="OLLAMA\_HOST=0.0.0.0"

6、程序调用接口

golang实现例子：流式响应速度更快，用户体验更佳。

golang例子：非流式响应

package main

import (

"bufio"

"bytes"

"encoding/json"

"fmt"

"io/ioutil"

"net/http"

"os"

"strings"

"time"

)

const (

obaseURL = "http://localhost:11434/api"

omodelID = "qwen2:0.5b" // 选择合适的模型

oendpoint = "/chat" //"/chat/completions"

)

// ChatCompletionRequest 定义了请求体的结构

type olChatCompletionRequest struct {

Model string `json:"model"`

Messages []struct {

Role string `json:"role"`

Content string `json:"content"`

} `json:"messages"`

Stream bool `json:"stream"`

//Temperature float32 `json:"temperature"`

}

// ChatCompletionResponse 定义了响应体的结构

type olChatCompletionResponse struct {

//Choices []struct {

Message struct {

Role string `json:"role"`

Content string `json:"content"`

} `json:"message"`

//} `json:"choices"`

}

// sendRequestWithRetry 发送请求并处理可能的429错误

func olsendRequestWithRetry(client *http.Client, requestBody []byte) (*http.Response, error) {

req, err := http.NewRequest("POST", obaseURL+oendpoint, bytes.NewBuffer(requestBody))

if err != nil {

return nil, err

}

req.Header.Set("Content-Type", "application/json")

//req.Header.Set("Authorization", "Bearer "+apiKey)

resp, err := client.Do(req)

if err != nil {

return nil, err

}

if resp.StatusCode == http.StatusTooManyRequests {

retryAfter := resp.Header.Get("Retry-After")

if retryAfter != "" {

duration, _ := time.ParseDuration(retryAfter)

time.Sleep(duration)

} else {

time.Sleep(5 * time.Second) // 默认等待5秒

}

return olsendRequestWithRetry(client, requestBody) // 递归重试

}

return resp, nil

}

func main() {

client := &http.Client{} // 创建一个全局的 HTTP 客户端实例

// 初始化对话历史记录

history := []struct {

Role string `json:"role"`

Content string `json:"content"`

}{

{"system", "你是一位唐代诗人，特别擅长模仿李白的风格。"},

}

// 创建标准输入的扫描器

scanner := bufio.NewScanner(os.Stdin)

for {

fmt.Print("请输入您的问题（或者输入 'exit' 退出）: ")

scanner.Scan()

userInput := strings.TrimSpace(scanner.Text())

// 退出条件

if userInput == "exit" {

fmt.Println("感谢使用，再见！")

break

}

// 添加用户输入到历史记录

history = append(history, struct {

Role string `json:"role"`

Content string `json:"content"`

}{

"user",

userInput,

})

// 创建请求体

requestBody := olChatCompletionRequest{

Model: omodelID,

Messages: history,

Stream: false,

//Temperature: 0.7,

}

// 构建完整的请求体，包含历史消息

requestBody.Messages = append([]struct {

Role string `json:"role"`

Content string `json:"content"`

}{

{

Role: "system",

Content: "你是一位唐代诗人，特别擅长模仿李白的风格。",

}, history...)

// 将请求体序列化为 JSON

requestBodyJSON, err := json.Marshal(requestBody)

if err != nil {

fmt.Println("Error marshalling request body:", err)

continue

}

fmt.Println("wocao:" + string(requestBodyJSON))

// 发送请求并处理重试

resp, err := olsendRequestWithRetry(client, requestBodyJSON)

if err != nil {

fmt.Println("Error sending request after retries:", err)

continue

}

defer resp.Body.Close()

// 检查响应状态码

if resp.StatusCode != http.StatusOK {

fmt.Printf("Received non-200 response status code: %d\n", resp.StatusCode)

continue

}

// 读取响应体

responseBody, err := ioutil.ReadAll(resp.Body)

if err != nil {

fmt.Println("Error reading response body:", err)

continue

}

//fmt.Println("0000" + string(responseBody))

// 解析响应体

var completionResponse olChatCompletionResponse

err = json.Unmarshal(responseBody, &completionResponse)

if err != nil {

fmt.Println("Error unmarshalling response body:", err)

continue

}

fmt.Printf("AI 回复: %s\n", completionResponse.Message.Content) // choice.Message.Content

// 将用户的消息添加到历史记录中

history = append(history, struct {

Role string `json:"role"`

Content string `json:"content"`

}{

Role: completionResponse.Message.Role,

Content: completionResponse.Message.Content, // 假设用户的消息是第一个

})

}

复制代码

golang例子：流式响应

复制代码

  1 package main
  2 
  3 import (
  4     "bufio"
  5     "bytes"
  6     "encoding/json"
  7     "fmt"
  8     "io"
  9     "net/http"
 10     "os"
 11     "strings"
 12     "time"
 13 )
 14 
 15 const (
 16     obaseURL  = "http://localhost:11434/api" 
 17     omodelID  = "qwen2:0.5b"                 // 选择合适的模型
 18     oendpoint = "/chat"                      //"/chat/completions"
 19 )
 20 
 21 // ChatCompletionRequest 定义了请求体的结构
 22 type olChatCompletionRequest struct {
 23     Model    string `json:"model"`
 24     Messages []struct {
 25         Role    string `json:"role"`
 26         Content string `json:"content"`
 27     } `json:"messages"`
 28     Stream bool `json:"stream"`
 29     //Temperature float32 `json:"temperature"`
 30 }
 31 
 32 // ChatCompletionResponse 定义了响应体的结构
 33 type olChatCompletionResponse struct {
 34     //Choices []struct {
 35     Message struct {
 36         Role    string `json:"role"`
 37         Content string `json:"content"`
 38     } `json:"message"`
 39     //} `json:"choices"`
 40 }
 41 
 42 // sendRequestWithRetry 发送请求并处理可能的429错误
 43 func olsendRequestWithRetry(client *http.Client, requestBody []byte) (*http.Response, error) {
 44     req, err := http.NewRequest("POST", obaseURL+oendpoint, bytes.NewBuffer(requestBody))
 45     if err != nil {
 46         return nil, err
 47     }
 48 
 49     req.Header.Set("Content-Type", "application/json")
 50     //req.Header.Set("Authorization", "Bearer "+apiKey)
 51 
 52     resp, err := client.Do(req)
 53     if err != nil {
 54         return nil, err
 55     }
 56 
 57     if resp.StatusCode == http.StatusTooManyRequests {
 58         retryAfter := resp.Header.Get("Retry-After")
 59         if retryAfter != "" {
 60             duration, _ := time.ParseDuration(retryAfter)
 61             time.Sleep(duration)
 62         } else {
 63             time.Sleep(5 * time.Second) // 默认等待5秒
 64         }
 65         return olsendRequestWithRetry(client, requestBody) // 递归重试
 66     }
 67 
 68     return resp, nil
 69 }
 70 
 71 func main() {
 72     client := &http.Client{} // 创建一个全局的 HTTP 客户端实例
 73 
 74     // 初始化对话历史记录
 75     history := []struct {
 76         Role    string `json:"role"`
 77         Content string `json:"content"`
 78     }{
 79         {"system", "你是一位唐代诗人，特别擅长模仿李白的风格。"},
 80     }
 81 
 82     // 创建标准输入的扫描器
 83     scanner := bufio.NewScanner(os.Stdin)
 84 
 85     for {
 86         fmt.Print("请输入您的问题（或者输入 'exit' 退出）: ")
 87         scanner.Scan()
 88         userInput := strings.TrimSpace(scanner.Text())
 89 
 90         // 退出条件
 91         if userInput == "exit" {
 92             fmt.Println("感谢使用，再见！")
 93             break
 94         }
 95 
 96         // 添加用户输入到历史记录
 97         history = append(history, struct {
 98             Role    string `json:"role"`
 99             Content string `json:"content"`
100         }{
101             "user",
102             userInput,
103         })
104 
105         // 创建请求体
106         requestBody := olChatCompletionRequest{
107             Model:    omodelID,
108             Messages: history,
109             Stream:   true,
110             //Temperature: 0.7,
111         }
112 
113         // 构建完整的请求体，包含历史消息
114         requestBody.Messages = append([]struct {
115             Role    string `json:"role"`
116             Content string `json:"content"`
117         }{
118             {
119                 Role:    "system",
120                 Content: "你是一位唐代诗人，特别擅长模仿李白的风格。",
121             },
122         }, history...)
123 
124         // 将请求体序列化为 JSON
125         requestBodyJSON, err := json.Marshal(requestBody)
126         if err != nil {
127             fmt.Println("Error marshalling request body:", err)
128             continue
129         }
130         fmt.Println("wocao:" + string(requestBodyJSON))
131         // 发送请求并处理重试
132         resp, err := olsendRequestWithRetry(client, requestBodyJSON)
133         if err != nil {
134             fmt.Println("Error sending request after retries:", err)
135             continue
136         }
137         defer resp.Body.Close()
138 
139         // 检查响应状态码
140         if resp.StatusCode != http.StatusOK {
141             fmt.Printf("Received non-200 response status code: %d\n", resp.StatusCode)
142             continue
143         }
144                resutlmessage := ""
145         streamReader := resp.Body
146         buf := make([]byte, 1024) // 或者使用更大的缓冲区来提高读取性能
147         var completionResponse olChatCompletionResponse
148         fmt.Print("AI 回复:")
149         for {
150             n, err := streamReader.Read(buf)
151             if n > 0 {
152                 // 处理接收到的数据，这里简单打印出来
153                 //fmt.Print(string(buf[:n]))
154                 err = json.Unmarshal(buf[:n], &completionResponse)
155                 fmt.Print(string(completionResponse.Message.Content))
156                                resutlmessage+=string(completionResponse.Message.Content)
157                 if err != nil {
158                     fmt.Println("Error unmarshalling response body:", err)
159                     continue
160                 }
161             }
162             if err != nil {
163                 if err == io.EOF {
164                     fmt.Println("")
165                     break
166                 }
167                 panic(err)
168             }
169         }
170 
171         // 将用户的消息添加到历史记录中
172         history = append(history, struct {
173             Role    string `json:"role"`
174             Content string `json:"content"`
175         }{
176             Role:    completionResponse.Message.Role,
177             Content: resutlmessage,//completionResponse.Message.Content, // 假设用户的消息是第一个
178         })
179     }
180 }

复制代码

感谢观看，谢谢！