# Збудувати "Lawyer GPT" для вашого блогу | МСК2 | Частина | 6: | Локальна інтеграція LLM

<!--category-- AI, LLM, LLamaSharp, GGUF, C#, AI-Article, mostlylucid.blogllm -->
<datetime class="hidden">2025-11-12T22:45</datetime>

## Введение

Добро пожаловать до частини 6! Ми МSK1 збудували повну інфраструктуру МSK2 канал для введення води ([Частина 4](/blog/building-a-lawyer-gpt-for-your-blog-part4)), Windows Client ([Частина 5](/blog/building-a-lawyer-gpt-for-your-blog-part5)), вбудова та пошук векторів МSK1[Частина 3](/blog/building-a-lawyer-gpt-for-your-blog-part3)), і налаштування GPU ([Частина 2](/blog/building-a-lawyer-gpt-for-your-blog-part2)). Тепер наступає захоплююча частина : інтегрування локального LLM, щоб дійсно генерувати написання запропонувань .

> NOTE: Це частина моїх експериментів з штучним інтелектом

Ось де ми нарешті зробили "AIM SK1 частину "AI-допомічника до написанняMSC3 робота. МиMST5 запустимо великі мовні моделі локально на вашому АMСК6 ҐПУМСК7 генеруємо контекстMSК8 усвідомлюємо запропонування, базовані на ваших попередніх блогових постахMSP9

[TOC]

## Чому локальний LLM?

Перед тим, як зануритися в це програмне забезпечення, потрібно зрозуміти, чому ми запускаємо моделі локально, а не OpenAI

### Порівняння локального з API

| Аспект МSK1 локальний LLM МSK2 API (OpenAI, і т.д.
|--------|-----------|-------------------|
| **Prywatність** МSK0 ✅ Завершити МSK2 \ ❌ Дані надсилаються третьій стороні |
| **Ціна** МSK0 ✅ Бесплатно після налагодження
| **Тривалість** МSK0 ✅ | | МSK2 секунда | | \ ⚠ ️ Залежність від мережі || |
| **Налагодження** МSK0 ✅ Полна контроль МSK2 ♫ ♫ ❌ ♫ Лідерна ♫ МSK4 ♫
| **Вибір моделі** МSK0 ✅ Будь-яка модель GGUF МSK2 ❌ Допомічник мSK4 тільки моделі МSK5
| **Оффлайн** | МSK1 Працює без зв 'язку з інтернетом
| **Налагодження** МSK0 ❌ Комплекс МSK2 \ ✅ Прості |

Для писемного асистента, конфіденційність та вартістьM SK1 Ми не хочемо' надсилати блогові креслення на зовнішні API , і за одинMSC4တန်ဖိုး токена швидко зростає для щоденного інструменту письмаMRK5

## Опції інтеграції LLM для C#

Існує декілька способів запуску LLM в C#:

```mermaid
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
```

**Мій вибір: LLamaSharp**

Чому?

- Нативні зв 'язки C# для ЛамиM SK1cpp (швидша бібліотека висновківMSC3
- Obsługа формату GGUF (модерні, квантовані моделіM SK2
- Побудоване прискорення CUDA-in
- Активний розвиток і велика спільнота
- Вона працює з Llama, Mistral, PhiM SK2 GemmaMSC3 і більше

## Усвідомлення форматів моделей & Квантованість

### Формат GGUF

[GGUF](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) (GPTM SK1Генератований об 'єднаний формат ) - це стандарт для ефективного запуску LLM

```mermaid
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
```

**Квантованість пояснена**:

- Оригинальна модель: M SK1бітові плавники (вельми великіMSC3 дуже точні)
- Q4: M SK1бітові чисті (75% менші МSK3 мінімальна втрата якості МSK4
- Q5/QM SK1 Чудове місце для більшості випадків використання
- Q8: БлизькоM SK1оригіналністьМSK2 все ще МSK3x менша

### Вибір моделі за допомогою обладнання

МSK0 Модель | Розмір МSK2QM SK3K_MMSC5 | Використовування VRAM мSK7 Установлення M8ГБМСК9
|-------|---------------|------------|-----------|------------|------------|---------|
| **Phi-3 Mini (3.8BM SK2** МSK0 2.3ГБ
| **Ллама 2 МSK1B** МSK0 4.1ГБ МSK2 \ \ ~6ГB | | \ МSK5 Стійний MSК6 \ MSК7 Хороший МСК8 ♪ \ СМСК9 Легкий СМСК10 \ SМСК11 \ Хороший
| **Містраль 7B** МSK0 4.1ГБ
| **Gemma 7B** МSK0 4.1ГБ
| **Ллама 3 МSK1B** МSK0 4.7ГБ МSK2 \~7ГB
| **Ллама 2 МSK1B** МSK0 7.4ГБ МSK2 \ \ ~10ГB | | \ МSK5 Ні МСК6 ♫ СМСК7️ Сильний MSК8 \ СМСК9 Хороший MSК10 ♪ \ MSК11 Кращий msк12

**Рекомендації GPU:**

- **8ГБ ВRAM**: Почнемо з **Містраль 7B** або **Phi-3 Mini** МSK0безпека)
- **12ГБ ВRAM**: **Ллама 3 МSK1B** (краща якістьM SK1 або **Містраль 7B** МSK0швидший)
- **16ГБ оперативної пам 'яті**: **Ллама 3 МSK1B** або спробувати **Моделі 13B**
- **Лише CPU-**: Будь-яка модель працює , просто набагато повільніше МSK2 почнемо з Phi

**Моя рекомендація**: **[Містраль 7B](https://mistral.ai/)** (нова версіяM SK1 або **[Лама 3](https://ai.meta.com/llama/)** 8B

- Отож, чудова якість для технічного письма
- Робить все для всіх розмірів GPU
- Досить швидко для інтерактивного використання
- Хороша в наступних інструкціях

## завантажуючи моделі

Моделі розповсюджуються на Hugging Face.

### Винайти моделі GGUF

1. Перейти до [Рухаючи обличчям](https://huggingface.co/models)
2. Поиск: `"mistral 7b gguf"`
3. Подивіться на квантування TheBloke' ( найпопулярнішіM SK2

**Прямі зв 'язки** МSK0TheBloke'с кількісними вирахункамиM SK2

- [МістральМSK0B-Instruct-vM SK3GGUF](https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF)
- [ЛламаМSK0B-ChatM SK2GGUF](https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF)
- [Llama-3-8BM SK1Instruct-GGUF](https://huggingface.co/QuantFactory/Meta-Llama-3-8B-Instruct-GGUF)

### завантажити специфічну квантізацію

```bash
# 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. Нажмите на вкладку " Файлі та версіїM SK1
2. Знайти `mistral-7b-instruct-v0.2.Q5_K_M.gguf` МSK0ГБ)
3. Нажмите  завантажити .
4. Врятувати до `C:\models\mistral-7b\`

## Установлення LLamaSharp

### Установити пакет NuGet

```bash
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)` - Коренная бібліотека
- `LLamaSharp.Backend.Cuda12` - [ЦUDA](https://developer.nvidia.com/cuda-toolkit) 12 двойники для прискорення GPU

### Перевірити зворотний бік CUDA

LLamaSharp автоматично розпізнає CUDA, якщо його правильно встановлено.

```csharp
using LLama;
using LLama.Common;

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

Якщо `false`МSK0 перевірити:

1. CUDA 12.x zainstalowanі (Part МSK2
2. `LLamaSharp.Backend.Cuda12` zainstalowanий пакет
3. PATH включає в себе каталог CUDA bin

## Збудувати службу LLM

### Параметри моделі

```csharp
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
    }
}
```

**Пояснення параметрів**:

- **Розмір контексту**: Скільки текстів модель може побачити "see МSK2 одночасно
  
  - 4096 टोकони МSK1 МSK2 слова
  - Більше = більше контексту, але повільніше і більше VRAM

- **Кількість шарів Gpu**: Скільки шарів трансформатора працює на GPU
  
  - Моделі 7B мають шари МSK1
  - МSK0 = помістити все на GPU МSK2 найшвидший )
  - Нижчі значення = використовують менше VRAM, але повільніше

- **Температура**: Kontrolує випадковість
  
  - МSK0 = завжди вибирайте найбільш можливий символ МSK2 непотрібний , повторюваний
  - МSK0 = хороший баланс МSK2 наш дефолт )
  - МSK0 = дуже творчий МSK2 може бути безглуздим )

- **TopP**: Випробовування ядра
  
  - 0.9 = розглянемо символи, що складають МSK2 маси ймовірності
  - Захищає відокремлення з дуже малоймовірного символу

### Втілення послуг LLM

```csharp
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. **Завантаження моделі**: Завантаження моделі GGUF у VRAM за допомогою визначених параметрів
2. **Интерактивний виконавець**: LLamaSharp ' tryb виконання для чату МSK2 подібної взаємодії
3. **Інферасинк**: Трохи टोकенів, як вони генеруються МSK1 МSK2 реальні - часовий вихід \ )
4. **Збудова контексту**: Об 'єднує прохання користувача з отриманими блоками блогу
5. **Анти--**: Закриває генерацію на деяких штринах (застерігає від перехилення

### Випробовування Служби

```csharp
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.
```

Дивовижно! Модель працює і генерує послідовнийM SK1 контекст- свідомий текст .

## Інтеграція з панелью запропонувань

Тепер дозвольте нам інтегрувати генерацію LLM в наш Windows-клиент з частини 5.

### Обновлюйте службу запропонувань

```csharp
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.";
        }
    }
}
```

### Обновлюйте модель представлень запропонувань

```csharp
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;
        }
    }
}
```

## Оптимізація ефективності

### Модель Caching

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

```csharp
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;
    }
}
```

### Знову використати KV Cache

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

```csharp
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);
    }
}
```

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

### Об 'єднання

Для численних запропонувань, подаруйте їх в партіюM SK1

```csharp
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;
}
```

## Проста інженерія для допомоги при написанні

Хороші пропони = хороший результат. Ось шаблони для різних сценаріївM SK2

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

```csharp
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:";
}
```

### Запропонуйте структуру секції

```csharp
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:";
}
```

### Ось приклад коду

```csharp
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:";
}
```

## Менеджмент пам 'яті

У великих моделях управління пам 'яттю є вирішальним

### Навігація використання VRAM

```csharp
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
    }
}
```

### Позбутись моделі, коли вона неактивна

```csharp
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);
    }
}
```

## Помилка в обробці

LLMs можуть провалитися непередбачувано.

```csharp
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");
}
```

## Підсумок

Ми ' успішно інтегрували локальну LLM гіпотезу :

1. ✅ Вибір [Лалам-Шарп](https://github.com/SciSharp/LLamaSharp) для інтеграції C#
2. ✅ Зрозуміла [Формат GGUF](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) та квантування
3. ✅ Вибраний відповідний модель МSK1[Містраль 7B](https://mistral.ai/) / [Лама 3](https://ai.meta.com/llama/) МSK0B)
4. ✅ Втілена LlmService з прискоренням CUDA
5. ✅ інтегрований з Windows-клиентом для запропонувань
6. ✅ Впроваджена швидка інженерія для написання завдань
7. ✅ Добавлена оптимізація ефективності (cachingM SK2 batching)
8. ✅ Руховане управління пам 'яттю та помилки

## Що' СледующаяM SK1

В **[Частина 7: генерація контенту МSK1 швидка інженерія](/blog/building-a-lawyer-gpt-for-your-blog-part7)**МСК0 ми ' зосередимося на повному газопроводі генерації контенту :

- Заawansовані методи швидкого проектування
- Multi- перемикає розмову для ітеративних покращень
- Стратегії управління контекстними вікнами
- Оцінювання та фільтрування якості
- Вказування на послідовність стилю
- Керування генерацією кодових блоків
- Реальний-схема використання світу

Ми зробимо систему дійсно корисною для щоденного написання блогу

## Навігація серії

- [Частина 1: Вprowadzenie МSK1 Архітектура](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- [Частина 2: Установка GPU & CUDA в C#](/blog/building-a-lawyer-gpt-for-your-blog-part2)
- [Частина 3: Порозуміння вбудованих компонентів МSK1 Вektorні бази даних](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Частина 4: Збудування каналу впиту](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Частина 5: Windows Client](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- **Частина 6: Локальна інтеграція LLM** (this postM SK1
- [Частина 7: генерація контенту МSK1 швидка інженерія](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Частина 8: Заawansовані характеристики & Розгортання виробництва](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## Ресурс

- [Документація LLamaSharp](https://scisharp.github.io/LLamaSharp/)
- [Спеціальність формату GGUF](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md)
- [Коллекция моделей TheBloke'](https://huggingface.co/TheBloke)
- [llama.cpp GitHub](https://github.com/ggerganov/llama.cpp)

Побачимося [Частина 7](/blog/building-a-lawyer-gpt-for-your-blog-part7)!