ollama搭建本地ai大模型並應用呼叫

小G同学發表於2024-08-19
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 }




 



感謝觀看，謝謝！












 




 














相關文章