ПОПЕРЕДЖЕННЯ: ТАКІ ПОСТА, ЯКІ ВАЖЛИВІ.

Це, ймовірно, багато з того, що нижче не спрацює, я генерую їх як як як як як-до мене, а потім роблю всі кроки і отримати зразок додатку працює... ви були підступні і бачили їх! вони ймовірно будуть готові до середини грудня.

Ласкаво просимо до 6 - ї частиниЧастина 4), клієнт Windows (Частина 5), вбудовування і векторний пошук (Частина 3), налаштування GPU (Частина 2

Тепер йде захоплююча частина: об'єднання місцевого LLM, щоб насправді створити пропозиції для написання.

ЗАУВАЖЕННЯ: це частина мого експерименту з комп'ютером (заступною чернеткою) + моїм власним редагуванням.

Той самий голос, той самий прагматизм, тільки швидші пальці.

Ось тут ми, нарешті, працюємо над частиною "АІ-а" асистента-ай-письменника.

Ми будемо проводити великі моделі мови локально на вашому A4000 GPU, створюючи пропозиції з вивчення контексту, засновані на ваших попередніх блогах. |--------|-----------|-------------------| | Чому локальний LLM? | ✅ Complete | ❌ Data sent to third party | | Перед тим, як зануритися, давайте зрозуміємо, чому ми працюємо над моделями локально замість використання API OpenAI. | ✅ Free after setup | ❌ Per-token pricing | | Порівняння локального інтерфейсу з API | ✅ <1 second | ⚠️ Network dependent | | Д_ д./ П. А. А. А. Л.М. (OpenAI, і т. д.) | ✅ Full control | ❌ Limited | | Конфіденційність | ✅ Any GGUF model | ❌ Provider's models only | | Вартість | ✅ Works offline | ❌ Requires internet | | Затримка | ❌ Complex | ✅ Simple |

Налаштування

Вибір моделі

Поза мережею

graph TB
    A[C# Application] --> B{Integration Method}

    B --> C[LLamaSharp]
    B --> D[ONNX Runtime]
    B --> E[TorchSharp]
    B --> F[HTTP API]

    C --> G[llama.cpp bindings]
    G --> H[GGUF Models]

    D --> I[ONNX Models]
    I --> J[Limited Model Support]

    E --> K[PyTorch Models]
    K --> L[Complex Setup]

    F --> M[External Process]
    M --> N[Ollama, LM Studio]

    class C recommended
    class G,H llamaSharp

    classDef recommended stroke:#333,stroke-width:4px
    classDef llamaSharp stroke:#333,stroke-width:2px

Налаштування

Для асистента письма, конфіденційність і вартість.

• Ми не хочемо, щоб блоги надсилалися до зовнішніх програм API, а для щоденної програми письма додається заміна.
• Параметри інтеграції LLM для C#
• Існує декілька способів запуску LLM у C#:
• Мій вибір: LLamaSap
• Чому?

Прив' язка C# для Lasa. cpp (найшвидша бібліотека підсумків)

Підтримує формат GGUF (сучасні, квантовані моделі)

Вбудоване прискорення CUDAАктивний розвиток і велика спільнота

graph LR
    A[Original Model<br/>Llama 2 7B<br/>~28GB float32] --> B[Quantization]

    B --> C[Q4_K_M<br/>~4.1GB<br/>4-bit]
    B --> D[Q5_K_M<br/>~4.8GB<br/>5-bit]
    B --> E[Q6_K<br/>~5.5GB<br/>6-bit]
    B --> F[Q8_0<br/>~7.2GB<br/>8-bit]

    C --> G[Fast, Lower Quality]
    D --> H[Balanced]
    E --> I[Higher Quality]
    F --> J[Near Original]

    class A original
    class C,D quantized
    class H recommended

    classDef original stroke:#333,stroke-width:2px
    classDef quantized stroke:#333,stroke-width:2px
    classDef recommended stroke:#333,stroke-width:2px

Працює з Ламою, Містралем, фі, Джеммою тощо.:

• Розуміння формату моделі і квантування
• Формат GGUF
• GGUF
• (GPT- Generated Unified Формат) є стандартним для ефективного запуску LLMs.

Пояснення квантизації

Початкова модель: 32- бітові floats (дуже великі, дуже точні) |-------|---------------|------------|-----------|------------|------------|---------| | Q4: 4- бітове ціле число (75% менше, мінімальна втрата якості) | 2.3GB | ~4GB | ✅ Easy | ✅ Easy | ✅ Easy | ⭐⭐⭐ Good | | Q5/Q6: Місце для більшості випадків використання | 4.1GB | ~6GB | ✅ Tight | ✅ Good | ✅ Easy | ⭐⭐⭐ Good | | Q8: Коротка якість, але менша у 4x | 4.1GB | ~6GB | ✅ Tight | ✅ Good | ✅ Easy | ⭐⭐⭐⭐ Better | | Модель вибраного за обладнанням | 4.1GB | ~6GB | ✅ Tight | ✅ Good | ✅ Easy | ⭐⭐⭐⭐ Better | | ** Makes (Q4_ K_ M) VRAM} is 8GB?} Що має значення 12GB?} має 16GB? ** | 4.7GB | ~7GB | ⚠️ Very Tight | ✅ Good | ✅ Easy | ⭐⭐⭐⭐⭐ Best | | Фі- 3 Міні (3,8Б) | 7.4GB | ~10GB | ❌ No | ⚠️ Tight | ✅ Good | ⭐⭐⭐⭐ Better |

Llama 2 7B

• Містраль 7Б7Б ДжеммиЛама 3 8БLlama 2 13B**Рекомендації GPU:**8GB VRAM
• : Почати з: Містраль 7БабоPhi- 3 Mini(безпечно)
• 12GB VRAM: Лама 3 8Б(найкраща якість) абоМістраль 7Б
• **(швидше)**16GB VRAM (створення моєї)

Лама 3 8Б: або спробувати13Б- моделіЛише ЦП: Будь- яка модель працює, набагато повільніше (почніть з Phi- 3 Mini для швидкості)

• Моя рекомендація
• Містраль 7Б
• (розкладна версія) або
• Ллама 3

8Б

Чудова якість для технічного запису

Працює у всіх розмірах GPU

1. Достатньо швидкий для інтерактивного використанняДобре виконується настанова
2. Звантаження моделей"mistral 7b gguf"
3. Моделі розповсюджуються на грабунках Лиця.

**Ми використаємо квантовані версії GGUF.**Пошук моделей GGUF

• Перейти до
• Об' єм гральних об' єктів
• Пошук:

Шукайте квантації TheBloke (найпопулярніше)

# Install huggingface-cli
pip install huggingface-hub

# Download Mistral 7B Q5_K_M (recommended)
huggingface-cli download TheBloke/Mistral-7B-Instruct-v0.2-GGUF \
    mistral-7b-instruct-v0.2.Q5_K_M.gguf \
    --local-dir C:\models\mistral-7b \
    --local-dir-use-symlinks False

Прямі посилання

1. (Ч):
2. Mistral- 7B- Instruction- v0. 2- GGUFmistral-7b-instruct-v0.2.Q5_K_M.ggufLlama- 2- 7B- Chat- GGUF
3. Llama- 3- 8B- Instruction- GGUF
4. Звантажити специфічну КвантаціюC:\models\mistral-7b\

Або звантажувати вручну:

Натисніть вкладку " Файли і версії "

cd Mostlylucid.BlogLLM.Core
dotnet add package LLamaSharp  # Latest version
dotnet add package LLamaSharp.Backend.Cuda12  # Latest, matching CUDA version

Знайти

• [LLamaSharp](https://github.com/SciSharp/LLamaSharp)(~4. 8GB)
• LLamaSharp.Backend.Cuda12 - Натисніть звантаженняЗберегти до

Налаштування & LLamashprent

Встановити пакунок NuGet

using LLama;
using LLama.Common;

// Check if CUDA is available
bool cudaAvailable = NativeLibraryConfig.Instance.CudaEnabled;
Console.WriteLine($"CUDA Available: {cudaAvailable}");

Почему два пакета?false- Основна бібліотека

1. КУДА
2. LLamaSharp.Backend.Cuda1212 бінарних пакунків для прискорення GPU
3. Перевірити сервер CUDA

LLamaSapd автоматично виявить CUDA, якщо його встановлено належним чином.

Якщо

using LLama;
using LLama.Common;

namespace Mostlylucid.BlogLLM.Core.Services
{
    public class ModelParameters
    {
        public string ModelPath { get; set; } = string.Empty;
        public int ContextSize { get; set; } = 4096;  // Context window
        public int GpuLayerCount { get; set; } = 35;  // Layers on GPU (35 = all for 7B)
        public int Seed { get; set; } = 1337;  // For reproducibility
        public float Temperature { get; set; } = 0.7f;  // Creativity (0.0 = deterministic, 1.0 = creative)
        public float TopP { get; set; } = 0.9f;  // Nucleus sampling
        public int MaxTokens { get; set; } = 500;  // Max generation length
    }
}

, перевірка::

• **Встановлено CUDA 12. x (Part 2)**встановлено пакунокThe role of the transaction, in present tense

  • PATH включає каталог bin CUDA
  • Побудова служби LLM

• Параметри моделіПояснення параметрів

  • ContextSize
  • : скільки текст може побачити модель одразу
  • 4096 - те, що означає " 3000 - річна ."

• Більший = контекст, але повільніший і повільніший VRAMGpuLayerCount

  • : Скільки шарів трансформаторів працює на GPU
  • 7B-моделі мають ~32- шари
  • 35 = покласти все на GPU (найшвидший)

• Нижні значення = використовують менше VRAM, але повільнішеТемпература

  • : Контролює випадковість
  • 0. 0 = завжди обирати найвірогідніший ключ (підбір, повторення)

0. 7 = добрий баланс (наш типовий)

using LLama;
using LLama.Common;
using Microsoft.Extensions.Logging;

namespace Mostlylucid.BlogLLM.Core.Services
{
    public interface ILlmService
    {
        Task<string> GenerateAsync(string prompt, CancellationToken cancellationToken = default);
        Task<string> GenerateWithContextAsync(string prompt, List<string> contextChunks, CancellationToken cancellationToken = default);
    }

    public class LlmService : ILlmService, IDisposable
    {
        private readonly LLamaWeights _model;
        private readonly LLamaContext _context;
        private readonly ILogger<LlmService> _logger;
        private readonly ModelParameters _parameters;

        public LlmService(ModelParameters parameters, ILogger<LlmService> logger)
        {
            _parameters = parameters;
            _logger = logger;

            _logger.LogInformation("Loading model from {ModelPath}", parameters.ModelPath);

            // Configure model parameters
            var modelParams = new ModelParams(parameters.ModelPath)
            {
                ContextSize = (uint)parameters.ContextSize,
                GpuLayerCount = parameters.GpuLayerCount,
                Seed = (uint)parameters.Seed,
                UseMemoryLock = true,  // Keep model in RAM
                UseMemorymap = true    // Memory-map the model file
            };

            // Load model
            _model = LLamaWeights.LoadFromFile(modelParams);
            _context = _model.CreateContext(modelParams);

            _logger.LogInformation("Model loaded successfully. VRAM used: ~{VRAM}GB",
                EstimateVRAMUsage(parameters.GpuLayerCount));
        }

        public async Task<string> GenerateAsync(string prompt, CancellationToken cancellationToken = default)
        {
            var executor = new InteractiveExecutor(_context);

            var inferenceParams = new InferenceParams
            {
                Temperature = _parameters.Temperature,
                TopP = _parameters.TopP,
                MaxTokens = _parameters.MaxTokens,
                AntiPrompts = new[] { "\n\nUser:", "###" }  // Stop generation at these
            };

            var result = new StringBuilder();

            _logger.LogInformation("Generating response for prompt: {Prompt}", TruncateForLog(prompt));

            await foreach (var token in executor.InferAsync(prompt, inferenceParams, cancellationToken))
            {
                result.Append(token);
            }

            var response = result.ToString().Trim();
            _logger.LogInformation("Generated {Tokens} tokens", CountTokens(response));

            return response;
        }

        public async Task<string> GenerateWithContextAsync(
            string prompt,
            List<string> contextChunks,
            CancellationToken cancellationToken = default)
        {
            // Build prompt with retrieved context
            var fullPrompt = BuildContextualPrompt(prompt, contextChunks);

            _logger.LogInformation("Context chunks: {Count}, Total prompt tokens: ~{Tokens}",
                contextChunks.Count, CountTokens(fullPrompt));

            return await GenerateAsync(fullPrompt, cancellationToken);
        }

        private string BuildContextualPrompt(string userPrompt, List<string> contextChunks)
        {
            var sb = new StringBuilder();

            sb.AppendLine("You are a helpful writing assistant for a technical blog.");
            sb.AppendLine("Use the following excerpts from past blog posts as context:");
            sb.AppendLine();

            for (int i = 0; i < contextChunks.Count; i++)
            {
                sb.AppendLine($"--- Context {i + 1} ---");
                sb.AppendLine(contextChunks[i]);
                sb.AppendLine();
            }

            sb.AppendLine("---");
            sb.AppendLine();
            sb.AppendLine("Based on the context above, help with the following:");
            sb.AppendLine(userPrompt);
            sb.AppendLine();
            sb.AppendLine("Response:");

            return sb.ToString();
        }

        private int CountTokens(string text)
        {
            // Rough estimate: 1 token ≈ 4 characters
            return text.Length / 4;
        }

        private string TruncateForLog(string text, int maxLength = 100)
        {
            if (text.Length <= maxLength) return text;
            return text.Substring(0, maxLength) + "...";
        }

        private double EstimateVRAMUsage(int gpuLayers)
        {
            // Rough estimate for 7B model
            return (gpuLayers / 35.0) * 6.0;  // ~6GB for full 7B model
        }

        public void Dispose()
        {
            _context?.Dispose();
            _model?.Dispose();
        }
    }
}

1. 0+ = дуже креативний (може бути нечутливим):

1. TopP: дискримінація Nucleus
2. 0. 9 = розгляд елементів, що становлять 90% маси ймовірностіЗапобігає вибірці з дуже малоймовірних елементів
3. Впровадження служби LLMЯк це працює
4. Завантаження моделі: Завантажує модель GGUF до VRAM з використанням вказаних параметрів
5. Інтерактивний екзекутор: Режим виконання LLamaSap для спілкування, подібних до балачки

InferAsync

using Microsoft.Extensions.Logging;

class Program
{
    static async Task Main(string[] args)
    {
        // Setup logging
        var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
        var logger = loggerFactory.CreateLogger<LlmService>();

        // Configure model
        var parameters = new ModelParameters
        {
            ModelPath = @"C:\models\mistral-7b\mistral-7b-instruct-v0.2.Q5_K_M.gguf",
            ContextSize = 4096,
            GpuLayerCount = 35,
            Temperature = 0.7f,
            MaxTokens = 200
        };

        // Create service
        using var llmService = new LlmService(parameters, logger);

        // Test simple generation
        Console.WriteLine("=== Test 1: Simple Generation ===\n");
        var response1 = await llmService.GenerateAsync(
            "Explain what Docker Compose is in 2-3 sentences."
        );
        Console.WriteLine(response1);
        Console.WriteLine("\n");

        // Test with context
        Console.WriteLine("=== Test 2: Generation with Context ===\n");
        var context = new List<string>
        {
            "Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application's services.",
            "In development, Docker Compose makes it easy to spin up all dependencies (databases, caches, etc.) with one command: docker-compose up."
        };

        var response2 = await llmService.GenerateWithContextAsync(
            "Write an introduction paragraph for a blog post about using Docker Compose for development dependencies.",
            context
        );
        Console.WriteLine(response2);
    }
}

: Потокові позначки, які буде створено (відтворення у режимі реального часу):

=== Test 1: Simple Generation ===

Docker Compose is a tool that allows you to define and run multi-container Docker applications using a simple YAML configuration file. It simplifies the process of managing multiple containers, networking, and volumes, making it ideal for development environments.

=== Test 2: Generation with Context ===

If you've ever found yourself juggling multiple terminal windows to start databases, caches, and other services for local development, Docker Compose is about to become your new best friend. This powerful tool lets you define your entire development environment in a single YAML file and spin everything up with one command. In this post, we'll explore how to leverage Docker Compose to manage all your development dependencies, making your local setup reproducible, shareable, and incredibly easy to manage.

Контекстна побудова

: Об' єднує запит користувача з отриманими шматками блогу

Згладжування

: Зупиняє створення на певних струнах (prents rambling)

namespace Mostlylucid.BlogLLM.Client.Services
{
    public class SuggestionService : ISuggestionService
    {
        private readonly BatchEmbeddingService _embeddingService;
        private readonly QdrantVectorStore _vectorStore;
        private readonly ILlmService _llmService;  // NEW

        public SuggestionService(
            BatchEmbeddingService embeddingService,
            QdrantVectorStore vectorStore,
            ILlmService llmService)  // NEW
        {
            _embeddingService = embeddingService;
            _vectorStore = vectorStore;
            _llmService = llmService;
        }

        public async Task<string> GenerateAiSuggestionAsync(
            string currentText,
            List<SimilarPost> context)
        {
            // Extract text from similar posts
            var contextChunks = context
                .Take(3)  // Top 3 most similar
                .Select(p => p.FullText)
                .ToList();

            // Determine what type of suggestion to generate
            var prompt = DeterminePromptType(currentText);

            // Generate suggestion
            var suggestion = await _llmService.GenerateWithContextAsync(
                prompt,
                contextChunks
            );

            return suggestion;
        }

        private string DeterminePromptType(string currentText)
        {
            // Analyze what user is writing
            var lines = currentText.Split('\n');
            var lastLine = lines.LastOrDefault(l => !string.IsNullOrWhiteSpace(l)) ?? "";

            // Is user starting a new section?
            if (lastLine.StartsWith("## "))
            {
                return "Suggest 3-5 bullet points for what this section could cover.";
            }

            // Is user writing code?
            if (lastLine.Contains("```"))
            {
                return "Suggest relevant code examples that might be useful here.";
            }

            // Is user writing an introduction?
            if (currentText.Length < 500 && currentText.Contains("## Introduction"))
            {
                return "Suggest 2-3 sentences to continue this introduction based on similar posts.";
            }

            // Default: continue current thought
            return "Suggest 1-2 sentences to continue the current paragraph in a natural way.";
        }
    }
}

Перевірка служби

public partial class SuggestionsViewModel : ViewModelBase
{
    [RelayCommand]
    private async Task RegenerateSuggestion()
    {
        IsGenerating = true;
        AiSuggestion = "Generating...";

        try
        {
            var currentText = GetCurrentEditorText();  // From messaging
            var suggestion = await _suggestionService.GenerateAiSuggestionAsync(
                currentText,
                SimilarPosts.ToList()
            );

            AiSuggestion = suggestion;
        }
        catch (Exception ex)
        {
            AiSuggestion = $"Error: {ex.Message}";
        }
        finally
        {
            IsGenerating = false;
        }
    }
}

Очікувався вивід

Дивовижно!

Модель працює і створює плавний текст, який підтримується контекстом.

public class LlmServiceFactory
{
    private static LlmService? _instance;
    private static readonly object _lock = new();

    public static LlmService GetInstance(ModelParameters parameters, ILogger<LlmService> logger)
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new LlmService(parameters, logger);
                }
            }
        }

        return _instance;
    }
}

Інтеграція з панеллю варіантів

Тепер давайте інтегруємо покоління LLM до нашого клієнта Windows з частини 5.

public class StatefulLlmService
{
    private readonly InferenceParams _defaultParams;
    private string _cachedPromptPrefix = string.Empty;

    public async Task<string> GenerateWithPrefixAsync(string prefix, string newPrompt)
    {
        // If prefix matches cached, reuse KV cache
        if (prefix == _cachedPromptPrefix)
        {
            // Only process new tokens
            return await GenerateAsync(newPrompt);
        }

        // Process entire prompt and cache
        _cachedPromptPrefix = prefix;
        return await GenerateAsync(prefix + newPrompt);
    }
}

Оновити службу пропозицій

Оновити RepositionsViewModel

Оптимізація швидкодії

public async Task<List<string>> GenerateBatchAsync(List<string> prompts)
{
    var results = new List<string>();

    foreach (var prompt in prompts)
    {
        // With KV cache reuse, subsequent prompts are faster
        results.Add(await GenerateAsync(prompt));
    }

    return results;
}

Модерне кешування

Зберігати модель завантаженою між запитами:

Перевизначення кешу KV

private string PromptContinueWriting(string currentText, List<string> context)
{
    return $@"You are a technical blog writing assistant.

Here are excerpts from similar blog posts:
{string.Join("\n\n", context.Select((c, i) => $"--- Post {i + 1} ---\n{c}"))}

Current draft:
{currentText}

Task: Suggest 2-3 sentences to naturally continue the current paragraph.
Keep the same technical depth and casual, pragmatic tone.

Suggestion:";
}

LLamaSharp підтримує повторне використання кешу KV для пришвидшених наступних поколінь:

private string PromptSectionStructure(string sectionTitle, List<string> context)
{
    return $@"You are a technical blog writing assistant.

Similar sections from past posts:
{string.Join("\n\n", context)}

New section: {sectionTitle}

Task: Suggest 4-6 bullet points for what this section should cover.
Format as a markdown list.

Bullets:";
}

Це особливо корисно для нашого випадку використання: контексти залишаються незмінними, тільки користувач змінює питання.

private string PromptCodeExample(string description, List<string> context)
{
    return $@"You are a C# coding assistant.

Relevant code from past posts:
{string.Join("\n\n", context)}

Task: {description}

Provide a clean, well-commented C# code example.

Code:";
}

Пакетне

Для декількох пропозицій пакетизуйте їх:

Пропонуйте їм допомогу в написанні

public class VramMonitor
{
    [DllImport("nvml.dll")]
    private static extern int nvmlDeviceGetMemoryInfo(IntPtr device, ref NvmlMemory memory);

    [StructLayout(LayoutKind.Sequential)]
    public struct NvmlMemory
    {
        public ulong Total;
        public ulong Free;
        public ulong Used;
    }

    public static (ulong used, ulong total) GetVramUsage()
    {
        // Simplified - actual implementation needs proper NVML initialization
        var memory = new NvmlMemory();
        // nvmlDeviceGetMemoryInfo(device, ref memory);

        return (memory.Used / 1024 / 1024, memory.Total / 1024 / 1024);  // Convert to MB
    }
}

Хороші варіанти = добрий результат.

public class LlmServiceWithUnload : IDisposable
{
    private LlmService? _service;
    private readonly Timer _unloadTimer;
    private DateTime _lastUsed;

    public LlmServiceWithUnload()
    {
        _unloadTimer = new Timer(CheckForUnload, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
    }

    private void CheckForUnload(object? state)
    {
        if (_service != null && (DateTime.Now - _lastUsed) > TimeSpan.FromMinutes(10))
        {
            _service.Dispose();
            _service = null;
            GC.Collect();
            Console.WriteLine("Model unloaded due to inactivity");
        }
    }

    public async Task<string> GenerateAsync(string prompt)
    {
        _lastUsed = DateTime.Now;

        if (_service == null)
        {
            // Reload model
            _service = CreateService();
        }

        return await _service.GenerateAsync(prompt);
    }
}

Ось шаблони для різних сценаріїв:

Продовжувати писати

public async Task<string> GenerateWithRetryAsync(string prompt, int maxRetries = 3)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await GenerateAsync(prompt);
        }
        catch (OutOfMemoryException)
        {
            _logger.LogWarning("OOM error, reducing max tokens");
            _parameters.MaxTokens = Math.Max(100, _parameters.MaxTokens / 2);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Generation failed, attempt {Attempt}/{Max}", i + 1, maxRetries);

            if (i == maxRetries - 1) throw;

            await Task.Delay(1000 * (i + 1));  // Exponential backoff
        }
    }

    throw new Exception("Generation failed after retries");
}

Пропонувати структуру розділів

Приклад коду

1. ✅ Chose Керування пам' яттюУ великих моделях вирішальне управління пам'яттю.
2. ✅ Understood Використання VRAM монітораНе завантажувати модель, якщо вона неактивна
3. ✅ Selected appropriate model (Обробка помилок / LLM може провалитися несподіваним чином.Працювати граціозно:
4. ✅ Implemented LlmService with CUDA acceleration
5. ✅ Integrated with Windows client for suggestions
6. ✅ Implemented prompt engineering for writing tasks
7. ✅ Added performance optimizations (caching, batching)
8. ✅ Handled memory management and errors

Зведення

Ми успішно інтегрували локальні підсумки LLM:**LLamaSap**для інтеграції C# Description of a condition. Do not translate key words (# V1S #, # V1 #,)

• Формат GGUF
• і квантування
• Містраль 7Б
• Ллама 3
• 8Б)
• Що далі?
• Вхід

Частина 7: створення вмісту і сприяння інженерії

Ми зосередимося на трубопроводі для створення вмісту:

• Складні інженерні прийоми
• Багатоповерхова розмова для повторювальних удосконалень
• Стратегії керування вікнами контексту
• Оцінка якості і фільтрування
• Керування послідовністю стилів
• Обробка створення блоків кодуШаблони використання реального світу
• Ми зробимо систему дійсно корисною для щоденного запису блогів!
• Серія Навігація

Частина 1: Вступ і архітектура

• Частина 2: налаштування і налаштування CUDA у C#
• Частина 3: Розуміння вбудовування баз даних та векторів
• Частина 4.
• Частина 5: Клієнт Windows

Частина 6: Інтеграція локального LLM(це повідомлення)!