# "Lakimies GPT:n" rakentaminen blogiisi - Osa 6: Paikallinen LLM-integraatio

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

VAROITUS: NÄYTTELEVÄT NÄYTTEET, JOITA EI OLE KÄYTETTY.

Se on todennäköisesti suuri osa siitä, mikä alla on, ei toimi. Minä luon nämä minulle ja sitten teen kaikki askeleet ja saat näytesovelluksen toimimaan...Olet ollut ovela ja nähnyt ne! ne ovat todennäköisesti valmiita joulukuun puolivälissä.

<img src="https://media1.tenor.com/m/_rQc7PIEqwQAAAAd/cat-hello-cat-peek.gif" height="300px" />
## Johdanto

Tervetuloa 6-osaan![Olemme rakentaneet täydellisen infrastruktuurin - nieluputken (](/blog/building-a-lawyer-gpt-for-your-blog-part4)4 osa[), Windows-asiakas (](/blog/building-a-lawyer-gpt-for-your-blog-part5)5 osa[), upotukset ja vektorihaku (](/blog/building-a-lawyer-gpt-for-your-blog-part3)3 osa[) ja GPU-asetukset (](/blog/building-a-lawyer-gpt-for-your-blog-part2)2 osa



Nyt tulee jännittävä osa: paikallisen LLM:n integrointi, jotta se todella tuottaisi kirjoitusehdotuksia.

[TOC]

## HUOMAUTUS: Tämä on osa kokeilujani tekoälyllä (avustettu suunnittelu) + omalla muokkauksellani.

Sama ääni, sama pragmatismi, vain nopeammat sormet.

### Täällä saamme vihdoin "AI:n" osan "AI:n kirjoittavan avustajan" työstämään.

Teemme isoja kielimalleja paikallisesti A4000 GPU:llasi ja luomme kontekstitietoisia ehdotuksia aiempien blogikirjoitustesi perusteella.
|--------|-----------|-------------------|
| **Miksi paikallinen LLM?** | ✅ Complete | ❌ Data sent to third party |
| **Ennen sukeltamista on ymmärrettävä, miksi teemme malleja paikallisesti sen sijaan, että käyttäisimme OpenAI:n API:tä.** | ✅ Free after setup | ❌ Per-token pricing |
| **Paikallinen vs. API-vertailu** | ✅ <1 second | ⚠️ Network dependent |
| **Paikallisen LLM:n API (OpenAI, jne.)** | ✅ Full control | ❌ Limited |
| **Yksityisyys** | ✅ Any GGUF model | ❌ Provider's models only |
| **Kustannukset** | ✅ Works offline | ❌ Requires internet |
| **Latenssi** | ❌ Complex | ✅ Simple |

Räätälöinti

## Mallivalinta

Offline

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

**Asetukset**

Kirjoittaja-avustajalle yksityisyys ja kustannukset ovat tärkeitä.

- Emme halua, että ulkoisiin API-puhelimiin lähetetään blogiluonnoksia, ja per-token-hinta vastaa nopeasti päivittäistä kirjoitustyökalua.
- LLM-integraatioasetukset C#:lle
- LLM:ien pyörittämiseen C#:ssa on useita tapoja:
- Minun valintani: STAMASharp
- Miksi?

## Native C# -sidokset lama.cpp:lle (nopein päättelykirjasto)

### Tukee GGUF-formaattia (modernit, kvantitoidut mallit)

[CUDA-kiihtyvyys sisäänrakennettuna](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md)Aktiivinen kehitys ja hieno yhteisö

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

**Toimii Llaman, Mistralin, Phi:n, Gemman ja muiden kanssa**:

- Malliformaattien ja kvantifioinnin ymmärtäminen
- GGUF-muoto
- GGUF
- (GPT-Generated Unified Format) on standardi LLM:ien tehokkaalle toiminnalle.

### Kvantifiointi selitetty

Alkuperäinen malli: 32-bittinen kelluke (erittäin suuri, erittäin tarkka)
|-------|---------------|------------|-----------|------------|------------|---------|
| **Q4: 4-bittiset kokonaisluvut (75 % pienempi, minimaalinen laatuhäviö)** | 2.3GB | ~4GB | ✅ Easy | ✅ Easy | ✅ Easy | ⭐⭐⭐ Good |
| **Q5/Q6: Makea paikka useimpiin käyttökohteisiin** | 4.1GB | ~6GB | ✅ Tight | ✅ Good | ✅ Easy | ⭐⭐⭐ Good |
| **Q8: Near-original laatu, edelleen 4x pienempi** | 4.1GB | ~6GB | ✅ Tight | ✅ Good | ✅ Easy | ⭐⭐⭐⭐ Better |
| **Mallivalinta laitteiston mukaan** | 4.1GB | ~6GB | ✅ Tight | ✅ Good | ✅ Easy | ⭐⭐⭐⭐ Better |
| **Malli Koko (Q4_K_M) VRAM Käyttöönotto 8GB? Sopivuus 12GB? Sopivuus 16GB?** | 4.7GB | ~7GB | ⚠️ Very Tight | ✅ Good | ✅ Easy | ⭐⭐⭐⭐⭐ Best |
| **Phi-3 Mini (3.8B)** | 7.4GB | ~10GB | ❌ No | ⚠️ Tight | ✅ Good | ⭐⭐⭐⭐ Better |

**Llama 2 7B**

- **Mistral 7B**Gemma 7B**Llama 3 8B**Llama 2 13B**GPU:n suositukset:**8GB VRAM
- **: Aloita**: **Mistral 7B**tai**Phi-3 Mini**(turvallisin)
- **12GB VRAM**: **Llama 3 8B**(paras laatu) tai**Mistral 7B**
- **(nopeammin)**16GB VRAM (asetteluni)

**Llama 3 8B**: **[tai kokeile](https://mistral.ai/)**13B-mallit**[Vain prosessori](https://ai.meta.com/llama/)**: Mikä tahansa malli toimii, vain paljon hitaammin (aloita Phi-3 Minillä nopeuteen)

- Suositukseni
- Mistral 7B
- (viimeisin versio) tai
- Llama 3

## 8B

Erinomainen laatu tekniseen kirjoittamiseen

### Toimii kaikissa GPU-kokoissa

1. Tarpeeksi nopea vuorovaikutteiseen käyttöön[Hyvä noudattamaan ohjeita](https://huggingface.co/models)
2. Ladataan malleja`"mistral 7b gguf"`
3. Mallit jaetaan Hugging Face -kanavalla.

**Käytämme kvantisoituja GGUF-versioita.**GGUF-mallien löytäminen

- [Siirry](https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF)
- [Höyrykasvot](https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF)
- [Etsi:](https://huggingface.co/QuantFactory/Meta-Llama-3-8B-Instruct-GGUF)

### Etsi TheBloken kvantitaatiot (suosituimmat)

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

Suorat linkit

1. (TheBloke's quantizations):
2. Mistral-7B-Instruct-v0.2-GGUF`mistral-7b-instruct-v0.2.Q5_K_M.gguf`Llama-2-7B-Chat-GGUF
3. Llama-3-8B-Instruct-GGUF
4. Lataa erityinen kvantifiointi`C:\models\mistral-7b\`

## Tai lataa käsin:

### Klikkaa "arkistot ja versiot" -välilehteä

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

**Etsi**

- `[LLamaSharp](https://github.com/SciSharp/LLamaSharp)`(~4,8GB)
- `LLamaSharp.Backend.Cuda12` - [Klikkaa latausta](https://developer.nvidia.com/cuda-toolkit)Tallenna

### LLAMASharp-asetus

Asenna NuGet-paketti

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

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

Miksi kaksi pakettia?`false`- Peruskirjasto

1. CUDA
2. `LLamaSharp.Backend.Cuda12`12 binääriä GPU-kiihdytykseen
3. Varmista CUDA-taustaosa

## LLAMASharp havaitsee CUDAn automaattisesti, jos se asennetaan oikein.

### Jos

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

**, tarkista:**:

- **CUDA 12.x asennettu (osa 2)**paketti asennettu
  
  - PATH sisältää CUDA bin -hakemiston
  - LLM-palvelun rakentaminen

- **Mallimuuttujat**Muuttujan selitykset
  
  - Kontekstikoko
  - : Kuinka paljon tekstiä malli voi "näyttää" kerralla
  - 4096 kuponkia â € € € 3000 sanaa

- **Suurempi = enemmän kontekstia, mutta hitaammin ja enemmän VRAM-muistia**GpuLayerCount
  
  - : Kuinka monta muuntajakerrosta GPU:lla on
  - 7B-malleissa on ~32 kerrosta
  - 35 = laita kaikki GPU:n päälle (nopein)

- **Alemmat arvot = vähemmän VRAM-muistia mutta hitaammin**Lämpötila
  
  - : Hallitsee sattumanvaraisuutta
  - 0.0 = Valitse aina todennäköisin rahake (tylsää, toistuvaa)

### 0,7 = hyvä saldo (oletusarvo)

```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,0+ = erittäin luova (voi olla järjetön)**:

1. **TopP**: Nucleus-näytteenotto
2. **0.9 = harkitaan rahakkeita, jotka muodostavat 90 prosenttia todennäköisyysmassasta**Estää näytteenoton hyvin epätodennäköisiltä rahakkeilta
3. **LLM-palvelun toteutus**Miten se toimii?
4. **Mallin lataus**: Lataa GGUF-mallin VRAM-muistiin käyttäen määriteltyjä parametreja
5. **Interactive Executor**: STAMASharpin toteutustila chatinkaltaisille vuorovaikutukselle

### InferAsync

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

**: Virrat kuponkeja, kun niitä syntyy (real-time output)**:

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

Kontekstin rakentaminen

## : Yhdistää käyttäjän pikavisiitin noudettuihin blogin osiin

Antipromptit

### : Pysäyttää sukupolvensa tietyillä naruilla (ehkäisee lavertelua)

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

### Palvelun testaaminen

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

## Odotettu tuotos

### Ihmeellistä!

Malli toimii ja tuottaa johdonmukaista, kontekstitietoista tekstiä.

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

### Integroituminen ehdotuspaneelin kanssa

Nyt integroidaan LLM-sukupolvi osa 5:n Windows-asiakkaaseemme.

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

Päivitä ehdotuspalvelu

### Päivitä ehdotuksetViewModel

Suorituskyvyn optimointi

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

## Malli Välimuisti

Pidä malli ladattuna pyyntöjen välillä:

### KV Cache- uudelleenkäyttö

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

### LLAMASharp tukee KV- välimuistin uudelleenkäyttöä nopeammille tuleville sukupolville:

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

### Tämä on erityisen hyödyllistä käyttökotelossamme - kontekstipalikat pysyvät ennallaan, vain käyttäjän kysymys muuttuu.

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

## Leikkaus

Useita ehdotuksia, erittele ne:

### Pikatekniikka kirjoitusapua varten

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

### Hyvät vinkit = hyvä ulostulo.

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

## Tässä mallit eri skenaarioille:

Jatka kirjoittamista

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

## Ehdota osion rakennetta

Koodiesimerkki

1. ✅ Chose [Muistinhallinta](https://github.com/SciSharp/LLamaSharp)Suurten mallien kohdalla muistinhallinta on ratkaisevan tärkeää.
2. ✅ Understood [Seuraa VRAM-muistin käyttöä](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md)Poista malli, kun se ei toimi
3. ✅ Selected appropriate model ([Virheiden käsittely](https://mistral.ai/) / [LLM:t voivat epäonnistua odottamattomalla tavalla.](https://ai.meta.com/llama/)Käsittely viehkeästi:
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

## Yhteenveto

Olemme onnistuneesti yhdistäneet paikallisen LLM:n johtopäätöksen:**[LLAMASharp](/blog/building-a-lawyer-gpt-for-your-blog-part7)**C#-integraatiolle

- GGUF-muoto
- ja kvantisointi
- Mistral 7B
- Llama 3
- 8B)
- Mitä seuraavaksi?
- Sisään

Osa 7: Content Generation & Prompt Engineering

## Keskitymme koko sisällöntuotantoputkeen:

- [Kehittyneet nopeat insinööritekniikat](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- [Monikäännöskeskustelu iteratiiviseen hiomiseen](/blog/building-a-lawyer-gpt-for-your-blog-part2)
- [Kontekstiikkunan hallintastrategiat](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Laadun arviointi ja suodatus](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Tyylien johdonmukaisuuden valvonta](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- **Käsittelykoodiblokin tuotanto**Reaalimaailman käyttötavat
- [Teemme järjestelmästä todella hyödyllisen päivittäisessä blogikirjoituksessa!](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Sarjanavigointi](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## Osa 1: Johdanto ja arkkitehtuuri

- [Osa 2: GPU:n asetukset ja CUDA C#-muodossa](https://scisharp.github.io/LLamaSharp/)
- [Osa 3: Understanding Upbeddings & Vector Databases](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md)
- [Osa 4: Ruoansulatusputken rakentaminen](https://huggingface.co/TheBloke)
- [Osa 5: Windows-asiakas](https://github.com/ggerganov/llama.cpp)

Osa 6: Paikallinen LLM-integraatio[(tässä virassa)](/blog/building-a-lawyer-gpt-for-your-blog-part7)!