{
  "model": "qwen3:4b",
  "prompt": "Ваш запрос",
  "stream": false,
  "format": "json",
  "options": {
    "temperature": 0.8,
    "top_p": 0.9,
    "top_k": 40,
    "num_predict": 512,
    "stop": ["\n", "###"],
    "repeat_penalty": 1.1,
    "presence_penalty": 0.0,
    "frequency_penalty": 0.0,
    "seed": 42,
    "mirostat": 0,
    "num_ctx": 2048,
    "num_thread": 8
  },
  "template": "{{ .Prompt }}",
  "context": [1, 2, 3]
}

{
  "temperature": 0.1,
  "top_p": 0.3,
  "top_k": 20,
  "repeat_penalty": 1.2
}

{
  "temperature": 0.9,
  "top_p": 0.95,
  "top_k": 60,
  "num_predict": 1024
}

{
  "temperature": 0.1,
  "seed": 42,
  "top_p": 0.1
}

#!/bin/bash

# Первый запрос - получаем контекст
echo "=== Первый запрос ==="
response1=$(curl -s http://localhost:11434/api/generate -d '{
  "model": "qwen3:4b",
  "prompt": "Расскажи о преимуществах языка Python",
  "stream": false,
  "format": "json",
  "options": {
    "temperature": 0.7,
    "top_p": 0.9,
    "top_k": 40,
    "num_predict": 256,
    "stop": ["\n", "###"],
    "repeat_penalty": 1.1,
    "presence_penalty": 0.0,
    "frequency_penalty": 0.0,
    "seed": 42,
    "mirostat": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1,
    "num_ctx": 2048,
    "num_thread": 8
  },
  "template": "Ответь как эксперт: {{ .Prompt }}\n\nОтвет:"
}')

# Извлекаем ответ и контекст
answer1=$(echo $response1 | jq -r '.response')
context=$(echo $response1 | jq '.context')
echo "Ответ: $answer1"
echo "Контекст получен"

# Второй запрос с контекстом
echo -e "\n=== Второй запрос с контекстом ==="
response2=$(curl -s http://localhost:11434/api/generate -d '{
  "model": "qwen3:4b",
  "prompt": "А какие у Python недостатки?",
  "context": '"$context"',
  "stream": false,
  "format": "text",
  "options": {
    "temperature": 0.5,
    "top_p": 0.8,
    "top_k": 30,
    "num_predict": 200,
    "stop": ["\n\n"],
    "repeat_penalty": 1.2,
    "seed": 123
  }
}')

answer2=$(echo $response2 | jq -r '.response')
echo "Ответ: $answer2"

# Создаем конфигурационный файл для первого запроса
cat > first_request.txt << 'EOF'
Расскажи о преимуществах языка Python для data science
EOF

# Первый запрос с полными параметрами через stdin
echo "=== Первый запрос ==="
response1=$(ollama run qwen3:4b --temperature 0.7 --top-p 0.9 --top-k 40 \
--num-predict 256 --seed 42 --mirostat 2 --mirostat-tau 5.0 --mirostat-eta 0.1 \
--repeat-penalty 1.1 --stop "\n" --stop "###" < first_request.txt)

echo "$response1"

# Сохраняем промпт для второго запроса
cat > second_request.txt << 'EOF'
А какие недостатки у Python для data science по сравнению с R?
EOF

# Второй запрос (Ollama run не поддерживает context напрямую, 
# поэтому используем альтернативный подход)
echo -e "\n=== Второй запрос ==="
ollama run qwen3:4b --temperature 0.5 --top-p 0.8 --top-k 30 \
--num-predict 200 --seed 123 --repeat-penalty 1.2 < second_request.txt

# Alias для работы с конфигурационным файлом
alias ollama-config='func() {
    local config_file="$1"
    local prompt="$2"
    
    if [ ! -f "$config_file" ]; then
        echo "Config file $config_file not found!"
        return 1
    fi
    
    # Читаем конфигурацию из файла
    local model=$(yq eval ".model" "$config_file")
    local temperature=$(yq eval ".options.temperature" "$config_file")
    local top_p=$(yq eval ".options.top_p" "$config_file")
    local top_k=$(yq eval ".options.top_k" "$config_file")
    local num_predict=$(yq eval ".options.num_predict" "$config_file")
    local seed=$(yq eval ".options.seed" "$config_file")
    
    # Выполняем запрос
    ollama run "$model" --temperature "$temperature" --top-p "$top_p" \
    --top-k "$top_k" --num-predict "$num_predict" --seed "$seed" "$prompt"
}; func'

# Alias для JSON конфигурации
alias ollama-json='func() {
    local config_file="$1"
    local prompt="$2"
    
    if [ ! -f "$config_file" ]; then
        echo "Config file $config_file not found!"
        return 1
    fi
    
    # Используем jq для извлечения параметров
    local model=$(jq -r ".model" "$config_file")
    local temperature=$(jq -r ".options.temperature" "$config_file")
    local top_p=$(jq -r ".options.top_p" "$config_file")
    
    ollama run "$model" --temperature "$temperature" --top-p "$top_p" "$prompt"
}; func'

model: qwen3:4b
options:
  temperature: 0.7
  top_p: 0.9
  top_k: 40
  num_predict: 256
  seed: 42
  repeat_penalty: 1.1
  mirostat: 2
  mirostat_tau: 5.0
  mirostat_eta: 0.1
format: text

# Установите yq для работы с YAML: brew install yq
ollama-config ollama_config.yaml "Расскажи о machine learning"

# Или с JSON конфигом
ollama-json config.json "Напиши код на Python"

{
  "model": "qwen3:4b",
  "prompt": "Объясни концепцию искусственного интеллекта",
  "stream": false,
  "format": "markdown",
  "options": {
    "temperature": 0.7,
    "top_p": 0.9,
    "top_k": 40,
    "num_predict": 300,
    "stop": ["\n", "##"],
    "repeat_penalty": 1.1,
    "presence_penalty": 0.0,
    "frequency_penalty": 0.0,
    "seed": 424242,
    "mirostat": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1,
    "num_ctx": 2048,
    "num_thread": 8
  },
  "template": "Ответь как эксперт по AI: {{ .Prompt }}\n\n"
}

#!/bin/bash

process_ollama_config() {
    local config_file="$1"
    
    if [ ! -f "$config_file" ]; then
        echo "Config file $config_file not found!"
        return 1
    fi
    
    # Извлекаем параметры из JSON
    local model=$(jq -r '.model' "$config_file")
    local prompt=$(jq -r '.prompt' "$config_file")
    local temperature=$(jq -r '.options.temperature' "$config_file")
    local top_p=$(jq -r '.options.top_p' "$config_file")
    local top_k=$(jq -r '.options.top_k' "$config_file")
    local num_predict=$(jq -r '.options.num_predict' "$config_file")
    local seed=$(jq -r '.options.seed' "$config_file")
    local repeat_penalty=$(jq -r '.options.repeat_penalty' "$config_file")
    
    # Строим команду ollama run
    local command="ollama run '$model' --temperature $temperature --top-p $top_p --top-k $top_k --num-predict $num_predict --seed $seed --repeat-penalty $repeat_penalty"
    
    # Добавляем stop слова если они есть
    local stop_words=$(jq -r '.options.stop[]?' "$config_file" 2>/dev/null)
    if [ -n "$stop_words" ]; then
        while IFS= read -r word; do
            command+=" --stop \"$word\""
        done <<< "$stop_words"
    fi
    
    # Добавляем промпт
    command+=" \"$prompt\""
    
    echo "Выполняем команду: $command"
    eval "$command"
}

# Использование
process_ollama_config "request_config.json"

#!/bin/bash

# Прямое использование JSON конфига с curl
curl -s http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d "$(cat request_config.json)" \
  | jq -r '.response'

#!/bin/bash

CONFIG_FILE="dialog_config.json"
CONTEXT_FILE="context.json"

# Функция для отправки запроса
send_request() {
    local prompt="$1"
    local context="${2:-null}"
    
    local request_data=$(jq --arg prompt "$prompt" --argjson context "$context" '
    {
        model: .model,
        prompt: $prompt,
        stream: false,
        format: .format,
        options: .options,
        template: .template,
        context: $context
    }' "$CONFIG_FILE")
    
    curl -s http://localhost:11434/api/generate \
        -H "Content-Type: application/json" \
        -d "$request_data"
}

# Основной диалог
echo "🤖 Начинаем диалог с AI"

# Шаг 1
echo "👤: Расскажи о Python"
response1=$(send_request "Расскажи о Python")
answer1=$(echo $response1 | jq -r '.response')
context=$(echo $response1 | jq '.context')
echo "🤖: $answer1"

# Сохраняем контекст
echo "$context" > "$CONTEXT_FILE"

# Шаг 2 с контекстом
echo -e "\n👤: А какие у него недостатки?"
response2=$(send_request "А какие у него недостатки?" "$(cat $CONTEXT_FILE)")
answer2=$(echo $response2 | jq -r '.response')
echo "🤖: $answer2"

# Обновляем контекст
echo "$(echo $response2 | jq '.context')" > "$CONTEXT_FILE"

# Шаг 3
echo -e "\n👤: Что посоветуешь для изучения?"
response3=$(send_request "Что посоветуешь для изучения?" "$(cat $CONTEXT_FILE)")
answer3=$(echo $response3 | jq -r '.response')
echo "🤖: $answer3"

{
  "model": "qwen3:4b",
  "format": "text",
  "template": "Ответь дружелюбно и подробно: {{ .Prompt }}\n\n",
  "options": {
    "temperature": 0.7,
    "top_p": 0.9,
    "top_k": 40,
    "num_predict": 200,
    "stop": ["\n\n", "###"],
    "repeat_penalty": 1.1,
    "seed": 12345,
    "mirostat": 1,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1
  }
}

chmod +x advanced_dialog.sh
./advanced_dialog.sh

npm init -y
npm install axios

const axios = require('axios');

class OllamaClient {
    constructor(baseURL = 'http://localhost:11434') {
        this.baseURL = baseURL;
        this.context = null;
    }

    /**
     * Генерация текста с полным набором параметров
     */
    async generate({
        prompt,
        model = 'qwen3:4b',
        stream = false,
        format = 'text',
        temperature = 0.7,
        top_p = 0.9,
        top_k = 40,
        num_predict = 256,
        stop = ['\n', '###'],
        repeat_penalty = 1.1,
        presence_penalty = 0.0,
        frequency_penalty = 0.0,
        seed = null,
        mirostat = 0,
        mirostat_tau = 5.0,
        mirostat_eta = 0.1,
        num_ctx = 2048,
        num_thread = 8,
        template = null,
        useContext = true
    }) {
        const payload = {
            model,
            prompt,
            stream,
            format,
            options: {
                temperature,
                top_p,
                top_k,
                num_predict,
                stop,
                repeat_penalty,
                presence_penalty,
                frequency_penalty,
                mirostat,
                mirostat_tau,
                mirostat_eta,
                num_ctx,
                num_thread
            }
        };

        // Добавляем опциональные параметры
        if (seed !== null) {
            payload.options.seed = seed;
        }

        if (template) {
            payload.template = template;
        }

        if (useContext && this.context) {
            payload.context = this.context;
        }

        try {
            const response = await axios.post(`${this.baseURL}/api/generate`, payload, {
                timeout: 30000
            });

            // Сохраняем контекст для следующего запроса
            if (useContext && response.data.context) {
                this.context = response.data.context;
            }

            return response.data;

        } catch (error) {
            console.error('Ошибка запроса:', error.message);
            return { error: error.message };
        }
    }

    /**
     * Чат-интерфейс с поддержкой истории
     */
    async chat(messages, model = 'qwen3:4b', options = {}) {
        try {
            const response = await axios.post(`${this.baseURL}/api/chat`, {
                model,
                messages,
                stream: false,
                options
            }, {
                timeout: 30000
            });

            return response.data;

        } catch (error) {
            console.error('Ошибка чата:', error.message);
            return { error: error.message };
        }
    }

    /**
     * Очистить контекст
     */
    clearContext() {
        this.context = null;
    }

    /**
     * Сохранить контекст в файл
     */
    async saveContext(filename) {
        const fs = require('fs').promises;
        try {
            await fs.writeFile(filename, JSON.stringify(this.context, null, 2));
            console.log(`Контекст сохранен в ${filename}`);
        } catch (error) {
            console.error('Ошибка сохранения контекста:', error.message);
        }
    }

    /**
     * Загрузить контекст из файла
     */
    async loadContext(filename) {
        const fs = require('fs').promises;
        try {
            const data = await fs.readFile(filename, 'utf8');
            this.context = JSON.parse(data);
            console.log(`Контекст загружен из ${filename}`);
        } catch (error) {
            console.error('Ошибка загрузки контекста:', error.message);
        }
    }
}

// Пример использования
async function main() {
    const client = new OllamaClient();

    // Пример 1: Простая генерация
    console.log('=== Пример 1: Простая генерация ===');
    const result1 = await client.generate({
        prompt: 'Расскажи о JavaScript и его особенностях',
        model: 'qwen3:4b',
        temperature: 0.7,
        top_p: 0.9,
        num_predict: 200,
        seed: 42,
        format: 'text'
    });

    console.log('Ответ:', result1.response || result1.error);

    // Пример 2: Продолжение с контекстом
    console.log('\n=== Пример 2: Продолжение с контекстом ===');
    const result2 = await client.generate({
        prompt: 'А какие современные фреймворки используются?',
        temperature: 0.5,
        top_p: 0.8
    });

    console.log('Ответ:', result2.response || result2.error);

    // Пример 3: Чат с историей
    console.log('\n=== Пример 3: Чат-интерфейс ===');
    const chatResult = await client.chat([
        { role: 'user', content: 'Привет! Расскажи о Node.js' },
        { role: 'assistant', content: 'Node.js - это JavaScript runtime...' },
        { role: 'user', content: 'Какие пакеты самые популярные?' }
    ], 'qwen3:4b', {
        temperature: 0.6,
        top_p: 0.85
    });

    console.log('Чат ответ:', chatResult.message?.content || chatResult.error);

    // Пример 4: Сохранение и загрузка контекста
    await client.saveContext('context.json');
    client.clearContext();
    await client.loadContext('context.json');

    // Пример 5: Генерация кода с специфическими параметрами
    console.log('\n=== Пример 5: Генерация кода ===');
    const codeResult = await client.generate({
        prompt: 'Напиши простой HTTP сервер на Node.js',
        temperature: 0.3,
        top_p: 0.7,
        num_predict: 300,
        seed: 12345,
        format: 'code',
        stop: ['```']
    });

    console.log('Сгенерированный код:');
    console.log(codeResult.response || codeResult.error);
}

// Запуск примера
main().catch(console.error);

{
  "name": "ollama-client",
  "version": "1.0.0",
  "description": "Ollama client with full parameters support",
  "main": "ollama-client.js",
  "scripts": {
    "start": "node ollama-client.js",
    "dev": "node ollama-client.js"
  },
  "dependencies": {
    "axios": "^1.6.0"
  },
  "keywords": ["ollama", "ai", "llm", "javascript"],
  "author": "Your Name",
  "license": "MIT"
}

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Контекст очищен")
}

pip install requests python-dotenv

import requests
import json
import os
from typing import Dict, Any, List, Optional

class OllamaClient:
    def __init__(self, base_url: str = "http://localhost:11434"):
        self.base_url = base_url
        self.context = None
    
    def generate(
        self,
        prompt: str,
        model: str = "qwen3:4b",
        stream: bool = False,
        format: str = "text",
        temperature: float = 0.7,
        top_p: float = 0.9,
        top_k: int = 40,
        num_predict: int = 256,
        stop: List[str] = None,
        repeat_penalty: float = 1.1,
        presence_penalty: float = 0.0,
        frequency_penalty: float = 0.0,
        seed: int = None,
        mirostat: int = 0,
        mirostat_tau: float = 5.0,
        mirostat_eta: float = 0.1,
        num_ctx: int = 2048,
        num_thread: int = 8,
        template: str = None,
        use_context: bool = True
    ) -> Dict[str, Any]:
        """
        Генерация текста с полным набором параметров
        """
        if stop is None:
            stop = ["\n", "###"]
        
        payload = {
            "model": model,
            "prompt": prompt,
            "stream": stream,
            "format": format,
            "options": {
                "temperature": temperature,
                "top_p": top_p,
                "top_k": top_k,
                "num_predict": num_predict,
                "stop": stop,
                "repeat_penalty": repeat_penalty,
                "presence_penalty": presence_penalty,
                "frequency_penalty": frequency_penalty,
                "mirostat": mirostat,
                "mirostat_tau": mirostat_tau,
                "mirostat_eta": mirostat_eta,
                "num_ctx": num_ctx,
                "num_thread": num_thread
            }
        }
        
        # Добавляем опциональные параметры
        if seed is not None:
            payload["options"]["seed"] = seed
        
        if template:
            payload["template"] = template
        
        if use_context and self.context:
            payload["context"] = self.context
        
        try:
            response = requests.post(
                f"{self.base_url}/api/generate",
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            result = response.json()
            
            # Сохраняем контекст для следующего запроса
            if use_context and "context" in result:
                self.context = result["context"]
            
            return result
            
        except requests.exceptions.RequestException as e:
            print(f"Ошибка запроса: {e}")
            return {"error": str(e)}
    
    def chat(
        self,
        messages: List[Dict[str, str]],
        model: str = "qwen3:4b",
        **kwargs
    ) -> Dict[str, Any]:
        """
        Чат-интерфейс с поддержкой истории сообщений
        """
        payload = {
            "model": model,
            "messages": messages,
            "stream": False,
            "options": kwargs.get("options", {})
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/api/chat",
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.RequestException as e:
            print(f"Ошибка чата: {e}")
            return {"error": str(e)}
    
    def clear_context(self):
        """Очистить контекст"""
        self.context = None

# Пример использования
def main():
    client = OllamaClient()
    
    # Пример 1: Простая генерация
    print("=== Пример 1: Простая генерация ===")
    result1 = client.generate(
        prompt="Расскажи о преимуществах Python для data science",
        model="qwen3:4b",
        temperature=0.7,
        top_p=0.9,
        num_predict=150,
        seed=42,
        format="text"
    )
    print("Ответ:", result1.get("response", "Ошибка"))
    
    # Пример 2: Продолжение с контекстом
    print("\n=== Пример 2: Продолжение с контекстом ===")
    result2 = client.generate(
        prompt="А какие недостатки у Python?",
        temperature=0.5,
        top_p=0.8
    )
    print("Ответ:", result2.get("response", "Ошибка"))
    
    # Пример 3: Чат с историей
    print("\n=== Пример 3: Чат-интерфейс ===")
    chat_result = client.chat(
        messages=[
            {"role": "user", "content": "Привет! Как тебя зовут?"},
            {"role": "assistant", "content": "Привет! Я помощник на основе AI."},
            {"role": "user", "content": "Расскажи о машинном обучении"}
        ],
        model="qwen3:4b",
        options={
            "temperature": 0.7,
            "top_p": 0.9
        }
    )
    print("Чат ответ:", chat_result.get("message", {}).get("content", "Ошибка"))
    
    # Пример 4: Сброс контекста
    client.clear_context()
    print("\nКонтекст очищен")

if __name__ == "__main__":
    main()