ओलामा के लिए गो क्लाइंट्स: SDK तुलना और क्वेन3/जीपीटी-ओएसएस उदाहरण

package main

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

// ---- चैट API प्रकार ----

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

type ChatRequest struct {
	Model    string        `json:"model"`
	Messages []ChatMessage `json:"messages"`
	// कुछ सर्वर विचार नियंत्रण को एक बूलियन फ्लैग के रूप में प्रदान करते हैं।
	// यही छोड़ दिया जाए तो आप Qwen3 को /think या /no_think टैग के माध्यम से नियंत्रित कर सकते हैं।
	Think   *bool          `json:"think,omitempty"`
	Stream  *bool          `json:"stream,omitempty"`
	Options map[string]any `json:"options,omitempty"`
}

type ChatResponse struct {
	Model     string `json:"model"`
	CreatedAt string `json:"created_at"`
	Message   struct {
		Role     string `json:"role"`
		Content  string `json:"content"`
		Thinking string `json:"thinking,omitempty"` // जब विचार चालू होता है तो उपस्थित
	} `json:"message"`
	Done bool `json:"done"`
}

// ---- जनरेट API प्रकार ----

type GenerateRequest struct {
	Model   string         `json:"model"`
	Prompt  string         `json:"prompt"`
	Think   *bool          `json:"think,omitempty"`
	Stream  *bool          `json:"stream,omitempty"`
	Options map[string]any `json:"options,omitempty"`
}

type GenerateResponse struct {
	Model     string `json:"model"`
	CreatedAt string `json:"created_at"`
	Response  string `json:"response"`           // अनुक्रमित टेक्स्ट के लिए अंतिम
	Thinking  string `json:"thinking,omitempty"` // जब विचार चालू होता है तो उपस्थित
	Done      bool   `json:"done"`
}

// ---- सहायता फ़ंक्शन ----

func httpPostJSON(url string, payload any) ([]byte, error) {
	body, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}
	c := &http.Client{Timeout: 60 * time.Second}
	resp, err := c.Post(url, "application/json", bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	return io.ReadAll(resp.Body)
}

// bptr एक बूलियन मान के लिए एक संकेतक लौटाता है
func bptr(b bool) *bool { return &b }

func chatQwen3Thinking() error {
	endpoint := "http://localhost:11434/api/chat"

	req := ChatRequest{
		Model:   "qwen3:8b-thinking", // खींचे गए कोई भी :*-thinking टैग
		Think:   bptr(true),
		Stream:  bptr(false),
		Messages: []ChatMessage{
			{Role: "system", Content: "आप एक बर्दाश्त करने वाला सहायक हैं।"},
			{Role: "user",   Content: "एक छोटे गो उदाहरण के साथ पुनर्भावना की व्याख्या करें।"},
		},
	}

	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out ChatResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	fmt.Println("🧠 सोच:\n", out.Message.Thinking)
	fmt.Println("\n💬 उत्तर:\n", out.Message.Content)
	return nil
}

// अगले चरण में सोच बंद करने के लिए:
// (a) Think=false सेट करें, और/या
// (b) सबसे हालिया प्रणाली/उपयोगकर्ता संदेश में "/no_think" जोड़ें (Qwen3 नरम स्विच)।
// Qwen3 बहु-चरण चैट में अंतिम /think या /no_think निर्देश का सम्मान करता है।
func chatQwen3NoThinking() error {
	endpoint := "http://localhost:11434/api/chat"

	req := ChatRequest{
		Model:  "qwen3:8b-thinking",
		Think:  bptr(false),
		Stream: bptr(false),
		Messages: []ChatMessage{
			{Role: "system", Content: "आप संक्षिप्त हैं। /no_think"},
			{Role: "user",   Content: "एक वाक्य में पुनर्भावना की व्याख्या करें।"},
		},
	}

	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out ChatResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	// अपेक्षा करें कि सोच खाली है; फिर भी घोषणात्मक रूप से संभालें।
	if out.Message.Thinking != "" {
		fmt.Println("🧠 सोच (अप्रत्याशित):\n", out.Message.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", out.Message.Content)
	return nil
}

func chatGptOss() error {
	endpoint := "http://localhost:11434/api/chat"

	req := ChatRequest{
		Model:  "gpt-oss:20b",
		Think:  bptr(true),   // समर्थित अलग तर्क की अपेक्षा करें
		Stream: bptr(false),
		Messages: []ChatMessage{
			{Role: "user", Content: "डायनामिक कार्यक्रमित क्या है? मूल विचार की व्याख्या करें।"},
		},
	}

	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out ChatResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	// ज्ञात अजीब बात: सोच बंद करना gpt-oss:20b पर पूरी तरह से तर्क को बंद कर सकता है।
	// अगर आप इसे दिखाना नहीं चाहते हैं तो हमेशा सोच को फ़िल्टर/छिपाएं।
	fmt.Println("🧠 सोच:\n", out.Message.Thinking)
	fmt.Println("\n💬 उत्तर:\n", out.Message.Content)
	return nil
}

func generateQwen3() error {
	endpoint := "http://localhost:11434/api/generate"
	req := GenerateRequest{
		Model:  "qwen3:4b-thinking",
		Prompt: "2–3 वाक्यों में, डेटाबेस में B-ट्री के उपयोग क्या हैं?",
		Think:  bptr(true),
	}
	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out GenerateResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	if out.Thinking != "" {
		fmt.Println("🧠 सोच:\n", out.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", out.Response)
	return nil
}

func generateGptOss() error {
	endpoint := "http://localhost:11434/api/generate"
	req := GenerateRequest{
		Model:  "gpt-oss:20b",
		Prompt: "न्यूरल नेटवर्क में बैकप्रोपैगेशन की छोटी व्याख्या करें।",
		Think:  bptr(true),
	}
	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out GenerateResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	if out.Thinking != "" {
		fmt.Println("🧠 सोच:\n", out.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", out.Response)
	return nil
}

go get github.com/ollama/ollama/api

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/ollama/ollama/api"
)

func chatWithQwen3Thinking(ctx context.Context, thinking bool) error {
	client, err := api.ClientFromEnvironment() // OLLAMA_HOST को अगर सेट करता है तो सम्मान करता है
	if err != nil {
		return err
	}

	req := &api.ChatRequest{
		Model: "qwen3:8b-thinking",
		// कई सर्वर बिल्ड सोच को एक शीर्ष स्तरीय फ्लैग के रूप में प्रदान करते हैं;
		// अतिरिक्त, आप Qwen3 को संदेशों में /think या /no_think के माध्यम से नियंत्रित कर सकते हैं।
		Think: api.Ptr(thinking),
		Messages: []api.Message{
			{Role: "system", Content: "आप एक बर्दाश्त करने वाला सहायक हैं।"},
			{Role: "user",   Content: "एक छोटे गो अंतर्जाल के साथ मर्ज सॉर्ट की व्याख्या करें।"},
		},
	}

	var resp api.ChatResponse
	if err := client.Chat(ctx, req, &resp); err != nil {
		return err
	}

	if resp.Message.Thinking != "" {
		fmt.Println("🧠 सोच:\n", resp.Message.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", resp.Message.Content)
	return nil
}

func main() {
	ctx := context.Background()
	if err := chatWithQwen3Thinking(ctx, true); err != nil {
		log.Fatal(err)
	}
	// उदाहरण: असोच
	if err := chatWithQwen3Thinking(ctx, false); err != nil {
		log.Fatal(err)
	}
}

func chatWithGptOss(ctx context.Context) error {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return err
	}
	req := &api.ChatRequest{
		Model: "gpt-oss:20b",
		Think: api.Ptr(true),
		Messages: []api.Message{
			{Role: "user", Content: "मेमोइजेशन क्या है और यह कब उपयोगी है?"},
		},
	}
	var resp api.ChatResponse
	if err := client.Chat(ctx, req, &resp); err != nil {
		return err
	}
	// अगर आप तर्क को छिपाना चाहते हैं, तो चिह्नों के बिना यहां करें।
	if resp.Message.Thinking != "" {
		fmt.Println("🧠 सोच:\n", resp.Message.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", resp.Message.Content)
	return nil
}

func generateWithQwen3(ctx context.Context) error {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return err
	}
	req := &api.GenerateRequest{
		Model:  "qwen3:4b-thinking",
		Prompt: "B-ट्री के सूचीबद्ध में भूमिका का सारांश दें।",
		Think:  api.Ptr(true),
	}
	var resp api.GenerateResponse
	if err := client.Generate(ctx, req, &resp); err != nil {
		return err
	}
	if resp.Thinking != "" {
		fmt.Println("🧠 सोच:\n", resp.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", resp.Response)
	return nil
}

func generateWithGptOss(ctx context.Context) error {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return err
	}
	req := &api.GenerateRequest{
		Model:  "gpt-oss:20b",
		Prompt: "सरल शब्दों में ग्रेडिएंट डिसेंट की व्याख्या करें।",
		Think:  api.Ptr(true),
	}
	var resp api.GenerateResponse
	if err := client.Generate(ctx, req, &resp); err != nil {
		return err
	}
	if resp.Thinking != "" {
		fmt.Println("🧠 सोच:\n", resp.Thinking)
	}
	fmt.Println("\n💬 उत्तर:\n", resp.Response)
	return nil
}

func streamChatExample() error {
	endpoint := "http://localhost:11434/api/chat"
	req := ChatRequest{
		Model:  "qwen3:8b-thinking",
		Think:  bptr(true),
		Stream: bptr(true), // स्ट्रीमिंग को सक्षम करें
		Messages: []ChatMessage{
			{Role: "user", Content: "क्विकसॉर्ट एल्गोरिदम के चरणों की एक-एक करके व्याख्या करें।"},
		},
	}

	body, _ := json.Marshal(req)
	resp, err := http.Post(endpoint, "application/json", bytes.NewReader(body))
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	decoder := json.NewDecoder(resp.Body)
	for {
		var chunk ChatResponse
		if err := decoder.Decode(&chunk); err == io.EOF {
			break
		} else if err != nil {
			return err
		}
		
		// सोच और सामग्री के आगमन के साथ प्रोसेस करें
		if chunk.Message.Thinking != "" {
			fmt.Print(chunk.Message.Thinking)
		}
		fmt.Print(chunk.Message.Content)
		
		if chunk.Done {
			break
		}
	}
	return nil
}

func streamWithOfficialSDK(ctx context.Context) error {
	client, _ := api.ClientFromEnvironment()
	
	req := &api.ChatRequest{
		Model: "qwen3:8b-thinking",
		Think: api.Ptr(true),
		Messages: []api.Message{
			{Role: "user", Content: "बाइनरी खोज वृक्षों की व्याख्या करें।"},
		},
	}
	
	err := client.Chat(ctx, req, func(resp api.ChatResponse) error {
		if resp.Message.Thinking != "" {
			fmt.Print(resp.Message.Thinking)
		}
		fmt.Print(resp.Message.Content)
		return nil
	})
	
	return err
}

func robustChatRequest(ctx context.Context, model string, messages []api.Message) (*api.ChatResponse, error) {
	// उचित समय सीमा सेट करें
	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
	defer cancel()
	
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return nil, fmt.Errorf("क्लाइंट बनाने में त्रुटि: %w", err)
	}
	
	req := &api.ChatRequest{
		Model:    model,
		Messages: messages,
		Options: map[string]interface{}{
			"temperature": 0.7,
			"num_ctx":     4096, // संदर्भ विंडो आकार
		},
	}
	
	var resp api.ChatResponse
	if err := client.Chat(ctx, req, &resp); err != nil {
		return nil, fmt.Errorf("चैट अनुरोध विफल रहा: %w", err)
	}
	
	return &resp, nil
}

type OllamaService struct {
	client *api.Client
}

func NewOllamaService() (*OllamaService, error) {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return nil, err
	}
	return &OllamaService{client: client}, nil
}

func (s *OllamaService) Chat(ctx context.Context, req *api.ChatRequest) (*api.ChatResponse, error) {
	var resp api.ChatResponse
	if err := s.client.Chat(ctx, req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

export OLLAMA_HOST=http://localhost:11434
export OLLAMA_NUM_PARALLEL=2
export OLLAMA_MAX_LOADED_MODELS=2

func loggedChat(ctx context.Context, logger *log.Logger, req *api.ChatRequest) error {
	start := time.Now()
	client, _ := api.ClientFromEnvironment()
	
	var resp api.ChatResponse
	err := client.Chat(ctx, req, &resp)
	
	duration := time.Since(start)
	logger.Printf("model=%s duration=%v error=%v tokens=%d", 
		req.Model, duration, err, len(resp.Message.Content))
	
	return err
}