Запуск модели Ollama на языке Go

go mod init ollama-client
go get github.com/valyala/fasthttp

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"strings"
	"time"
	
	"github.com/valyala/fasthttp"
)

type OllamaOptions struct {
	Temperature      float32  `json:"temperature"`
	TopP             float32  `json:"top_p"`
	TopK             int      `json:"top_k"`
	NumPredict       int      `json:"num_predict"`
	Stop             []string `json:"stop"`
	RepeatPenalty    float32  `json:"repeat_penalty"`
	PresencePenalty  float32  `json:"presence_penalty"`
	FrequencyPenalty float32  `json:"frequency_penalty"`
	Seed             int64    `json:"seed,omitempty"`
	Mirostat         int      `json:"mirostat"`
	MirostatTau      float32  `json:"mirostat_tau"`
	MirostatEta      float32  `json:"mirostat_eta"`
	NumCtx           int      `json:"num_ctx"`
	NumThread        int      `json:"num_thread"`
}

type OllamaRequest struct {
	Model    string       `json:"model"`
	Prompt   string       `json:"prompt"`
	Stream   bool         `json:"stream"`
	Format   string       `json:"format,omitempty"`
	Options  OllamaOptions `json:"options"`
	Template string       `json:"template,omitempty"`
	Context  []int        `json:"context,omitempty"`
}

type OllamaResponse struct {
	Model     string `json:"model"`
	Response  string `json:"response"`
	Context   []int  `json:"context,omitempty"`
	Done      bool   `json:"done"`
	Error     string `json:"error,omitempty"`
}

type OllamaClient struct {
	BaseURL string
	Context []int
}

func NewOllamaClient(baseURL string) *OllamaClient {
	if baseURL == "" {
		baseURL = "http://localhost:11434"
	}
	return &OllamaClient{BaseURL: baseURL}
}

func (c *OllamaClient) Generate(prompt string, options OllamaOptions) (OllamaResponse, error) {
	request := OllamaRequest{
		Model:   "qwen3:4b",
		Prompt:  prompt,
		Stream:  false,
		Format:  "text",
		Options: options,
	}
	
	if len(c.Context) > 0 {
		request.Context = c.Context
	}
	
	requestBody, err := json.Marshal(request)
	if err != nil {
		return OllamaResponse{}, err
	}
	
	req := fasthttp.AcquireRequest()
	defer fasthttp.ReleaseRequest(req)
	
	req.SetRequestURI(c.BaseURL + "/api/generate")
	req.Header.SetMethod("POST")
	req.Header.SetContentType("application/json")
	req.SetBody(requestBody)
	
	resp := fasthttp.AcquireResponse()
	defer fasthttp.ReleaseResponse(resp)
	
	client := &fasthttp.Client{
		ReadTimeout: 30 * time.Second,
	}
	
	if err := client.Do(req, resp); err != nil {
		return OllamaResponse{}, err
	}
	
	var response OllamaResponse
	if err := json.Unmarshal(resp.Body(), &response); err != nil {
		return OllamaResponse{}, err
	}
	
	// Сохраняем контекст для следующих запросов
	if response.Context != nil {
		c.Context = response.Context
	}
	
	return response, nil
}

func (c *OllamaClient) ClearContext() {
	c.Context = nil
}

func main() {
	client := NewOllamaClient("")
	
	// Пример 1: Простая генерация
	options1 := OllamaOptions{
		Temperature:    0.7,
		TopP:           0.9,
		TopK:           40,
		NumPredict:     200,
		Stop:           []string{"\n", "###"},
		RepeatPenalty:  1.1,
		Seed:           42,
		Mirostat:       2,
		MirostatTau:    5.0,
		MirostatEta:    0.1,
	}
	
	fmt.Println("=== Пример 1: Простая генерация ===")
	response1, err := client.Generate("Расскажи о Go языке программирования", options1)
	if err != nil {
		log.Fatal("Ошибка:", err)
	}
	fmt.Printf("Ответ: %s\n", response1.Response)
	
	// Пример 2: Продолжение с контекстом
	options2 := OllamaOptions{
		Temperature:   0.5,
		TopP:          0.8,
		TopK:          30,
		NumPredict:    150,
		RepeatPenalty: 1.2,
	}
	
	fmt.Println("\n=== Пример 2: Продолжение с контекстом ===")
	response2, err := client.Generate("Какие у него преимущества?", options2)
	if err != nil {
		log.Fatal("Ошибка:", err)
	}
	fmt.Printf("Ответ: %s\n", response2.Response)
	
	// Пример 3: Генерация кода
	options3 := OllamaOptions{
		Temperature:  0.3,
		TopP:         0.7,
		NumPredict:   300,
		Seed:         12345,
	}
	
	fmt.Println("\n=== Пример 3: Генерация кода ===")
	response3, err := client.Generate("Напиши HTTP сервер на Go", options3)
	if err != nil {
		log.Fatal("Ошибка:", err)
	}
	fmt.Printf("Код: %s\n", response3.Response)
	
	// Очищаем контекст
	client.ClearContext()
	fmt.Println("\nКонтекст очищен")
}