Klienty Go dla Ollama: porównanie SDK oraz przykłady Qwen3/GPT-OSS

Integracja Ollama z Go: przewodnik po SDK, przykłady i najlepsze praktyki w środowisku produkcyjnym.

Page content

Ten przewodnik oferuje kompleksowy przegląd dostępnych Go SDKs dla Ollama i porównuje ich zestawy funkcji.

Zbadamy praktyczne przykłady w Go do wywoływania modeli Qwen3 i GPT-OSS hostowanych na Ollama — zarówno poprzez surowe wywołania API REST, jak i oficjalny klient Go — w tym szczegółowe obsługę trybów myślenia i niemyślenia w Qwen3.

go i ollama

Dlaczego Ollama + Go?

Ollama eksponuje mały, praktyczny HTTP API (zwykle działający na http://localhost:11434), zaprojektowane do obciążeń generowania i rozmowy, z wbudowaną obsługą strumieniowania i możliwością zarządzania modelami. Dokumentacja oficjalna dokładnie pokrywa struktury żądań i odpowiedzi /api/generate i /api/chat oraz semantykę strumieniowania.

Go to świetny wybór do budowania klientów Ollama dzięki silnej bibliotece standardowej dla HTTP, wspaniałej obsłudze JSON, natywnym elementom współbieżności i statycznie typowanym interfejsom, które wykrywają błędy w czasie kompilacji. Aby zobaczyć, jak Ollama porównuje się z vLLM, Docker Model Runner, LocalAI i dostawcami chmurowymi — w tym kiedy wybrać każdy — zobacz Hostowanie LLM: Lokalne, Samoobsługowe i Infrastruktura Chmurowa Porównane.

Na dzień 25 października 2025 roku, oto opcje SDK w Go, które najprawdopodobniej rozważysz.

SDK w Go dla Ollama — co jest dostępne?

SDK / Pakiet Status i „właściciel” Zakres (Generowanie/Rozmowa/Strumieniowanie) Zarządzanie modelami (ściąganie/lista itp.) Dodatki / Uwagi
github.com/ollama/ollama/api Oficjalny pakiet wewnątrz repozytorium Ollama; używany przez CLI ollama Pełna pokrycie mapowane na REST; obsługiwane strumieniowanie Tak Uznawany za kanoniczny klient Go; API dokładnie odzwierciedla dokumentację.
LangChainGo (github.com/tmc/langchaingo/llms/ollama) Komunitarny framework (LangChainGo) z modułem LLM dla Ollama Rozmowa/Pełne + strumieniowanie poprzez abstrakcje frameworku Ograniczona (zarządzanie modelami nie jest głównym celem) Świetny, jeśli chcesz łańcuchy, narzędzia, magazyny wektorowe w Go; mniej surowego SDK.
github.com/swdunlop/ollama-client Komunitarny klient Skupia się na rozmowie; dobre eksperymenty z wywołaniem narzędzi Częściowe Stworzony do eksperymentowania z wywołaniem narzędzi; nie jest 1:1 pełnym interfejsem.
Inne komunitarne SDK (np. ollamaclient, trzecie strony „go-ollama-sdk”) Komunitarny Wariuje Wariuje Jakość i zakres różnią się; oceniaj na repozytorium.

Rekomendacja: Dla produkcji preferuj github.com/ollama/ollama/api — jest utrzymywany wraz z projektem bazowym i dokładnie odzwierciedla REST API.

Qwen3 & GPT-OSS na Ollama: myślenie vs. niemyślenie (co warto wiedzieć)

  • Tryb myślenia w Ollama oddziela „rozumowanie” modelu od końcowego wyniku, gdy jest włączony. Ollama dokumentuje pierwszorzędne włączenie/wyłączenie myślenia w obsługiwanych modelach.
  • (https://www.glukhov.org/pl/llm-performance/benchmarks/qwen3-30b-vs-gpt-oss-20b/ “Qwen3:30b vs GPT-OSS:20b: Szczegóły techniczne, porównanie wydajności i szybkości”) obsługuje dynamiczne przełączanie: dodaj /think lub /no_think w komunikatach systemowych/użytkownika, aby przełączać tryby po kolei; najnowsze polecenie wygrywa.
  • GPT-OSS: użytkownicy raportują, że wyłączenie myślenia (np. /set nothink lub --think=false) może być nieprawidłowe na gpt-oss:20b; planuj filtrację/ukrycie wszystkiego, co Twoja interfejs nie powinien powiadać.

Część 1 — Wywoływanie Ollama za pośrednictwem surowego REST (Go, net/http)

Udostępnione typy

Najpierw zdefiniujmy typy i funkcje pomocnicze, które wykorzystamy w naszych przykładach:

package main

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

// ---- Typy API do rozmowy ----

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

type ChatRequest struct {
	Model    string        `json:"model"`
	Messages []ChatMessage `json:"messages"`
	// Niektóre serwery eksponują kontrolę myślenia jako flagę logiczną.
	// Nawet jeśli zostanie pominięta, nadal możesz kontrolować Qwen3 za pomocą /think lub /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"` // obecny, gdy myślenie jest włączone
	} `json:"message"`
	Done bool `json:"done"`
}

// ---- Typy API do generowania ----

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"`           // końcowy tekst dla nie-strumieniowego
	Thinking  string `json:"thinking,omitempty"` // obecny, gdy myślenie jest włączone
	Done      bool   `json:"done"`
}

// ---- Funkcje pomocnicze ----

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 zwraca wskaźnik do wartości logicznej
func bptr(b bool) *bool { return &b }

Rozmowa — Qwen3 z myśleniem WŁĄCZONYM (i jak je wyłączyć)

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

	req := ChatRequest{
		Model:   "qwen3:8b-thinking", // dowolny tag :*-thinking, który pobrano
		Think:   bptr(true),
		Stream:  bptr(false),
		Messages: []ChatMessage{
			{Role: "system", Content: "Jesteś precyzyjnym asystentem."},
			{Role: "user",   Content: "Wyjaśnij rekurencję z krótkim przykładem w Go."},
		},
	}

	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("🧠 myślenie:\n", out.Message.Thinking)
	fmt.Println("\n💬 odpowiedź:\n", out.Message.Content)
	return nil
}

// Aby wyłączyć myślenie w kolejnym przejściu:
// (a) ustaw Think=false, i/lub
// (b) dodaj "/no_think" do najnowszego komunikatu systemowego/użytkownika (Qwen3 soft switch).
// Qwen3 uwzględnia najnowsze polecenie /think lub /no_think w wielokrotnych rozmowach.
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: "Jesteś krótki. /no_think"},
			{Role: "user",   Content: "Wyjaśnij rekurencję w jednym zdaniu."},
		},
	}

	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out ChatResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	// Oczekiwana sytuacja: myślenie puste; nadal obronić się defensywnie.
	if out.Message.Thinking != "" {
		fmt.Println("🧠 myślenie (nieoczekiwane):\n", out.Message.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\n", out.Message.Content)
	return nil
}

(Polecenie /think i /no_think Qwen3 jest dokumentowane przez zespół Qwen; ostatnie polecenie wygrywa w wielokrotnych rozmowach.)

Rozmowa — GPT-OSS z myśleniem (i zastrzeżenie)

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

	req := ChatRequest{
		Model:  "gpt-oss:20b",
		Think:  bptr(true),   // żądaj oddzielonego rozumowania, jeśli jest obsługiwane
		Stream: bptr(false),
		Messages: []ChatMessage{
			{Role: "user", Content: "Co to jest programowanie dynamiczne? Wyjaśnij główną ideę."},
		},
	}

	raw, err := httpPostJSON(endpoint, req)
	if err != nil {
		return err
	}
	var out ChatResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return err
	}
	// Znana dziwność: wyłączanie myślenia może nie całkowicie tłumić rozumowanie na gpt-oss:20b.
	// Zawsze filtruj/ukryj myślenie w interfejsie, jeśli nie chcesz, aby było widoczne.
	fmt.Println("🧠 myślenie:\n", out.Message.Thinking)
	fmt.Println("\n💬 odpowiedź:\n", out.Message.Content)
	return nil
}

Użytkownicy raportują, że wyłączanie myślenia na gpt-oss:20b (np. /set nothink lub --think=false) może być ignorowane — planuj filtrację po stronie klienta, jeśli jest to konieczne.

Generowanie — Qwen3 i GPT-OSS

func generateQwen3() error {
	endpoint := "http://localhost:11434/api/generate"
	req := GenerateRequest{
		Model:  "qwen3:4b-thinking",
		Prompt: "W 2–3 zdaniach, do czego służą drzewa B w bazach danych?",
		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("🧠 myślenie:\n", out.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\n", out.Response)
	return nil
}

func generateGptOss() error {
	endpoint := "http://localhost:11434/api/generate"
	req := GenerateRequest{
		Model:  "gpt-oss:20b",
		Prompt: "Krótko wyjaśnij propagację wstępującą w sieciach neuronowych.",
		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("🧠 myślenie:\n", out.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\n", out.Response)
	return nil
}

Shape i zachowanie strumienia pochodzą bezpośrednio z dokumentacji API Ollama.

Część 2 — Wywoływanie Ollama za pośrednictwem oficjalnego SDK w Go (github.com/ollama/ollama/api)

Oficjalny pakiet udostępnia Client z metodami, które odpowiadają API REST. Sam kliens Ollama korzysta z tego pakietu, aby komunikować się z usługą, co czyni go najbezpieczniejszym wyborem pod względem kompatybilności.

Instalacja

go get github.com/ollama/ollama/api

Rozmowa — Qwen3 (myślenie WŁĄCZONE / WYŁĄCZONE)

package main

import (
	"context"
	"fmt"
	"log"

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

func chatWithQwen3Thinking(ctx context.Context, thinking bool) error {
	client, err := api.ClientFromEnvironment() // uwzględnia OLLAMA_HOST, jeśli jest ustawione
	if err != nil {
		return err
	}

	req := &api.ChatRequest{
		Model: "qwen3:8b-thinking",
		// Wiele konstrukcji serwera eksponuje myślenie jako flagę najwyższego poziomu;
		// dodatkowo możesz kontrolować Qwen3 za pomocą /think lub /no_think w komunikatach.
		Think: api.Ptr(thinking),
		Messages: []api.Message{
			{Role: "system", Content: "Jesteś precyzyjnym asystentem."},
			{Role: "user",   Content: "Wyjaśnij sortowanie przez scalanie z krótkim fragmentem Go."},
		},
	}

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

	if resp.Message.Thinking != "" {
		fmt.Println("🧠 myślenie:\n", resp.Message.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\n", resp.Message.Content)
	return nil
}

func main() {
	ctx := context.Background()
	if err := chatWithQwen3Thinking(ctx, true); err != nil {
		log.Fatal(err)
	}
	// Przykład: niemyślenie
	if err := chatWithQwen3Thinking(ctx, false); err != nil {
		log.Fatal(err)
	}
}

Rozmowa — GPT-OSS (obsługa rozumowania defensywnie)

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: "Co to jest memoizacja i kiedy jest przydatna?"},
		},
	}
	var resp api.ChatResponse
	if err := client.Chat(ctx, req, &resp); err != nil {
		return err
	}
	// Jeśli zamierzasz ukryć rozumowanie, zrób to tutaj, niezależnie od flag.
	if resp.Message.Thinking != "" {
		fmt.Println("🧠 myślenie:\n", resp.Message.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\n", resp.Message.Content)
	return nil
}

Generowanie — Qwen3 & GPT-OSS

func generateWithQwen3(ctx context.Context) error {
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return err
	}
	req := &api.GenerateRequest{
		Model:  "qwen3:4b-thinking",
		Prompt: "Podsumuj rolę drzewa B w indeksowaniu.",
		Think:  api.Ptr(true),
	}
	var resp api.GenerateResponse
	if err := client.Generate(ctx, req, &resp); err != nil {
		return err
	}
	if resp.Thinking != "" {
		fmt.Println("🧠 myślenie:\n", resp.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\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: "Wyjaśnij gradient descent w prostych słowach.",
		Think:  api.Ptr(true),
	}
	var resp api.GenerateResponse
	if err := client.Generate(ctx, req, &resp); err != nil {
		return err
	}
	if resp.Thinking != "" {
		fmt.Println("🧠 myślenie:\n", resp.Thinking)
	}
	fmt.Println("\n💬 odpowiedź:\n", resp.Response)
	return nil
}

Powierzchnia oficjalnego pakietu odzwierciedla dokumentację REST i jest aktualizowana wraz z projektem bazowym.

Strumieniowe odpowiedzi

Dla rzeczywistego strumieniowania ustaw Stream: bptr(true) w swoim żądaniu. Odpowiedź zostanie dostarczona jako fragmenty JSON oddzielone nową linią:

func streamChatExample() error {
	endpoint := "http://localhost:11434/api/chat"
	req := ChatRequest{
		Model:  "qwen3:8b-thinking",
		Think:  bptr(true),
		Stream: bptr(true), // Włącz strumieniowanie
		Messages: []ChatMessage{
			{Role: "user", Content: "Wyjaśnij algorytm sortowania szybkiego krok po kroku."},
		},
	}

	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
		}
		
		// Przetwarzaj myślenie i zawartość, gdy przychodzą
		if chunk.Message.Thinking != "" {
			fmt.Print(chunk.Message.Thinking)
		}
		fmt.Print(chunk.Message.Content)
		
		if chunk.Done {
			break
		}
	}
	return nil
}

Z oficjalnym SDK, użyj funkcji wywołania zwrotnego do obsługi fragmentów strumienia:

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: "Wyjaśnij drzewa wyszukiwania binarnego."},
		},
	}
	
	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
}

Praca z Qwen3 myślenie vs. niemyślenie (praktyczna wskazówka)

  • Dwa mechanizmy:

    1. Flaga logiczna myślenie, wspierana przez funkcję myślenia Ollama; i
    2. soft switch Qwen3 /think i /no_think w najnowszym komunikacie systemowym/użytkownika. Najnowsze polecenie określa następne przejście.

  • Domyślny stan: niemyślenie do szybkich odpowiedzi; zwiększ do myślenia dla zadań wymagających krok po kroku rozumowania (matematyka, planowanie, debugowanie, złożone analizy kodu).

  • Interfejsy strumieniowe: gdy myślenie jest włączone, możesz zobaczyć przemieszane rozumowanie/zawartość w ramkach strumienia — buforuj lub renderuj je osobno i daj użytkownikom przełącznik „pokaż rozumowanie”. (Zobacz dokumentację API dla formatu strumienia.)

  • Wielokrotna rozmowa: Qwen3 pamięta tryb myślenia z poprzednich przejść. Jeśli chcesz przełączać go w trakcie rozmowy, użyj zarówno flagi, jak i polecenia soft-switch, aby zapewnić niezawodność.

Uwagi dotyczące GPT-OSS

  • Traktuj rozumowanie jako obecne nawet jeśli spróbowałeś go wyłączyć; filtruj po stronie klienta, jeśli Twoja UX nie powinna go wyświetlać.
  • Dla aplikacji produkcyjnych korzystających z GPT-OSS, zaimplementuj logikę filtrowania po stronie klienta, która może wykrywać i usuwać wzorce rozumowania, jeśli to konieczne.
  • Dokładnie przetestuj swoją wersję modelu GPT-OSS, ponieważ zachowanie może się różnić między różnymi kwantyzacjami i wersjami.

Praktyczne wskazówki i wskazówki do produkcji

Obsługa błędów i timeoutów

Zawsze zaimplementuj odpowiednie obsługę timeoutów i odzyskiwania błędów:

func robustChatRequest(ctx context.Context, model string, messages []api.Message) (*api.ChatResponse, error) {
	// Ustaw rozsądną granicę czasową
	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
	defer cancel()
	
	client, err := api.ClientFromEnvironment()
	if err != nil {
		return nil, fmt.Errorf("tworzenie klienta: %w", err)
	}
	
	req := &api.ChatRequest{
		Model:    model,
		Messages: messages,
		Options: map[string]interface{}{
			"temperature": 0.7,
			"num_ctx":     4096, // rozmiar okna kontekstu
		},
	}
	
	var resp api.ChatResponse
	if err := client.Chat(ctx, req, &resp); err != nil {
		return nil, fmt.Errorf("błąd żądania rozmowy: %w", err)
	}
	
	return &resp, nil
}

Pule połączeń i ich ponowne wykorzystanie

Ponownie używaj klienta Ollama między żądaniami, zamiast tworzyć nowego za każdym razem:

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
}

Konfiguracja środowiska

Używaj zmiennych środowiskowych dla elastycznej wdrażania:

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

Oficjalny SDK automatycznie uwzględnia OLLAMA_HOST za pomocą api.ClientFromEnvironment().

Monitorowanie i logowanie

Zaimplementuj strukturalne logowanie dla systemów produkcyjnych:

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
}

Podsumowanie

  • Dla projektów w Go, github.com/ollama/ollama/api to najbardziej kompletny, gotowy do produkcji wybór. Jest utrzymywany wraz z projektem bazowym Ollama, używany przez oficjalny CLI i oferuje pełną pokrycie API z gwarancją kompatybilności.

  • Dla wyższych abstrakcji, rozważ LangChainGo, jeśli potrzebujesz łańcuchów, narzędzi, magazynów wektorowych i rur RAG — choć zamienisz pewną kontrolę niskiego poziomu na wygoda.

  • Qwen3 daje Ci czystą, niezawodną kontrolę nad trybem myślenia za pomocą flag i przełączników na poziomie komunikatu (/think, /no_think), co czyni go idealnym dla aplikacji wymagających zarówno szybkich odpowiedzi, jak i głębokiego rozumowania.

  • Dla GPT-OSS, zawsze planuj czyszczenie wyjścia rozumowania po stronie klienta, gdy jest to konieczne, ponieważ flaga wyłączania myślenia może nie być zawsze zgodnie z oczekiwaniami.

  • W produkcji, zaimplementuj odpowiednie obsługa błędów, pulę połączeń, timeouty i monitorowanie, aby zbudować niezawodne aplikacje oparte na Ollama.

Kombinacja silnego typowania w Go, wspaniałej obsługi współbieżności i prostego API Ollama czyni z niego idealny stos do budowania aplikacji AI — od prostych chatbotów po złożone systemy RAG.

Kluczowe wnioski

Oto szybki przewodnik do wyboru swojego podejścia:

Przypadek użycia Zalecany podejście Dlaczego
Aplikacja produkcyjna github.com/ollama/ollama/api Oficjalna obsługa, pełna pokrycie API, utrzymywana wraz z projektem bazowym
RAG/łańcuchy/narzędzia LangChainGo Wyższe abstrakcje, integracje z magazynami wektorowymi
Nauka/eksperymentacja Surowy REST z net/http Pełna przejrzystość, brak zależności, edukacyjny
Szybkie prototypowanie Oficjalny SDK Zrównoważenie między prostotą a mocą
Interfejs strumieniowy Oficjalny SDK z wywołaniami zwrotnymi Wbudowana obsługa strumieniowania, czysty API

Wskazówki dotyczące wyboru modelu:

  • Qwen3: Najlepszy do aplikacji wymagających kontroli trybu myślenia, niezawodnych rozmów wielokrotnych
  • GPT-OSS: Silna wydajność, ale wymaga defensywnego obsługi wyjścia rozumowania
  • Inne modele: Dokładnie testuj; zachowanie myślenia zmienia się w zależności od rodziny modeli

Źródła i dalsze czytanie

Oficjalna dokumentacja

Alternatywy SDK w Go

Zasoby dotyczące modeli

Powiązane tematy

Inne przydatne linki

Aby uzyskać szersze porównanie Ollama z innymi lokalnymi i chmurowymi infrastrukturami LLM, sprawdź nasz Hostowanie LLM: Lokalne, samoobsługowe i chmurowe infrastruktury porównane.