# Збудувати " Адвокат GPT" для вашого блогу - Витончене підлаштування альтернативи LLM МSK3 RAG з Qdrant та Generic Online LLMs

<!--category-- AI, LLM, RAG, C#, Cloud, Qdrant, OpenAI -->
<datetime class="hidden">2025-11-12T22:45</datetime>

## Введение

У моєму [8-частина МSK1 Адвокат GPTM SK2 серії](/blog/building-a-lawyer-gpt-for-your-blog-part1), Я показав вам, як побудувати повний локальний RAG - базований ассистент для письма, використовуючи прискорення ҐПУ M SK2 локальні LLM МSK3 та векторні бази даних . Він

Але будьте чесними. МСК1 не кожен має робочу станцію з NVIDIA GPU. МSK2, МSK3, ГБ оперативної пам 'яті, МСК4 і терпіння до налагодження CUDA. ,, CuDNN, МСК6 та GGUF моделей. МСк7. А що, якщо ви просто хочете отримати переваги блогового асистента без інвестицій у обладнання?

У цій статті представлено альтернативу за допомогою хмари-, яка базується на альтернативіM SK1 той самий підхід RAG , той же векторний бази даних Qdrant МSK3 але використовуючи хмарні API LLM замість локального висновку M SK4 Подумайте про це як "Lawyer GPT Lite

Полне розголошення: ЯM SK1 я досі вивчаю, який підхід працює найкраще в praktyce , тож візьміть мої підрахунки затрат та твердження щодо ефективності з трішки солю МSK3 Що я можу сказати, це те, що цей хмарний підхід виявився надзвичайно простим для створення порівняно з маршрутом GPU

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

[TOC]

## Чому альтернатива хмарі?

### Початковий підхід

Полна серія "Lawyer GPTM SK1 створює систему, яка

- Працює 100% локально МSK1приватністьM SK2
- Жодних витрат на API
- швидке GPU- прискорене виведення
- Потрібна NVIDIA GPU (8GB+ VRAMM SK2
- Комплексна інсталяція (CUDAM SK1 cuDNN , управління моделями)
- Ограничений на моделі, які вміщуються у VRAM
- Розгортання Windows-

### Альтернатива хмари

Цей підхід дає вам

- Немає GPU. (гортає на будь-якому комп 'ютері
- Проста інсталяція (no CUDA/cuDNNM SK2
- Доступ до передових моделей (GPT-4, ClaudeM SK2 і т.д.
- Кросс-платформа
- Lepша якість виходу (великіші , більш здатні моделі МSK2
- Kosztи API ( хоча і прийнятні для особистого використання )
- Дані надсилаються на сторонні API
- Тривалість залежить від мережі

**Коли використовувати який?**

| Використовуйте локальний підхід | Виконуйте Cloud Approach МSK2
|--------------------|-------------------|
| Приватність є вирішальним МSK1 Удобство - найважливіше МSK2
| Ви маєте графічну комп 'ютерну систему | Ви МSK2 знаходитеся на Mac
МSK0 Використовування великих об 'ємів | Помірне використання
| Вам подобається tinkering | Ви хочете отримати результати швидко МSK2

[TOC]

## Уявлення про архітектуру

Версия хмари зберігає ті ж самі фундаментальні RAG, але обмінює локальну LLM гіпотезу на API дзвінки:

```mermaid
graph TB
    A[Markdown Files] -->|Ingest| B[Chunking Service]
    B -->|Text Chunks| C[Cloud Embedding API]
    C -->|Vectors| D[Qdrant Vector DB]

    E[User Writing] -->|Current Draft| F[Web/Desktop Client]
    F -->|Embed Context| C
    C -->|Query Vector| D
    D -->|Similar Content| G[Context Builder]

    G -->|Relevant Past Articles| H[Prompt Engineer]
    H -->|Prompt + Context| I[Cloud LLM API]
    I -->|Generated Suggestions| J[Response Handler]
    J -->|Suggestions + Citations| F

    F -->|Display| K[Editor with Suggestions]

    class C,I cloud
    class D,K local

    classDef cloud stroke:#f96,stroke-width:4px
    classDef local stroke:#333,stroke-width:2px
```

**Головні відмінності:**

- **Модель вбудованої**МSK0 OpenAI's `text-embedding-3-small` API замість локального BGE моделі
- **ЛЛМ**: Claude 3.5 Sonnet або GPT-4 API замість локального MistralM SK3Llama
- **Не обов 'язково мати GPU**: Все обчислення на основі процесора - локально МSK2 відбувається в хмарі
- **Простіше застосування**: Одноразовий застосовний , ніяких файлів моделі для управління

Я мушу зазначити, що я досі не провів масштабних тестів для порівняння двох підходів. Я досі в процесі дослідження. МSK3 Але перші результати досить перспективні, щоб поділитися ними.

## Набір технологій

### Коренная база

- **МSK0NET 9** - Те ж саме, що і з оригінальною серией
- **C# M SK1** - Современні мовні характеристики

### Хмарні API

- **OpenAI API** - Вбудовані матеріали МSK1текст МSK2вбудовані матеріали -3-маленькі
- **Антропічний API** - Альтернативний LLM  Клод МSK2 Сонет МSK3
- **Обидві** - Ви можете змішувати та порівняти

### База даних вектора

- **Кдрант** - Те ж саме, що й оригінал, можна запустити локально через Докер або використовувати Qdrant Cloud
- **Альтернатива**: Pinecone , Weaviate Cloud МSK2 Managed options

### Опції клієнта

- **Консольна програма** - Найпростіший , чудовий для тестування
- **Blazor WebAssembly** - Веб - базується на , працює будь-де
- **Авалонія** - Кроссіальний -платформенний десктоп МSK2WindowsM SK3 Mac, LinuxMSC5

## Установка: Швидкий шлях

### 1. Установити Qdrant

**Опція A: локальний докер ( Рекомендується для розробкиM SK2**

```bash
docker run -p 6333:6333 -p 6334:6334 \
    -v $(pwd)/qdrant_storage:/qdrant/storage:z \
    qdrant/qdrant
```

**Опція B: Qdrant Cloud (EasiestM SK2**

1. Зарегистрируйтесь на [хмара.qdrantM SK1io](https://cloud.qdrant.io)
2. Створити безкоштовний кластер
3. Візьміть ваш API ключ і кластер URL

**Ні CUDA, ні cuDNN, не потрібні інсталяції драйверів !**

### 2. Получите ключі API

**OpenAI** ( для вмонтування + LLMM SK2

1. Перейти до [платформа.openai.com](https://platform.openai.com)
2. Створити API ключ
3. Установити обмеження використання (важливеM SK1

**Антропічний** (опціонально, для КлодаM SK2

1. Перейти до [konsol.anthropic.com](https://console.anthropic.com)
2. Створити API ключ

### 3. Налаштування

Створити `appsettings.json`:

```json
{
  "BlogRAG": {
    "Embedding": {
      "Provider": "OpenAI",
      "Model": "text-embedding-3-small",
      "ApiKey": "sk-..."
    },
    "LLM": {
      "Provider": "Anthropic",
      "Model": "claude-3-5-sonnet-20241022",
      "ApiKey": "sk-ant-..."
    },
    "VectorStore": {
      "Type": "Qdrant",
      "Url": "http://localhost:6333",
      "ApiKey": "",
      "CollectionName": "blog_embeddings"
    },
    "Ingestion": {
      "MarkdownPath": "/path/to/your/blog/Markdown",
      "ChunkSize": 500,
      "ChunkOverlap": 50
    }
  }
}
```

**Це - МСК0, це - МSK1** Не встановлювати GPU, не завантажувати моделі M SK1 ГБ файлів), не управляти VRAM-комп 'ютером .

## Втілення

### Головні послуги

#### 1. Cloud Embedding Service

```csharp
using OpenAI;
using OpenAI.Embeddings;

namespace BlogRAG.Services
{
    public interface IEmbeddingService
    {
        Task<float[]> GenerateEmbeddingAsync(string text);
        Task<List<float[]>> GenerateBatchEmbeddingsAsync(List<string> texts);
    }

    public class OpenAIEmbeddingService : IEmbeddingService
    {
        private readonly OpenAIClient _client;
        private readonly string _model;
        private readonly ILogger<OpenAIEmbeddingService> _logger;

        public OpenAIEmbeddingService(
            string apiKey,
            string model,
            ILogger<OpenAIEmbeddingService> logger)
        {
            _client = new OpenAIClient(apiKey);
            _model = model;
            _logger = logger;
        }

        public async Task<float[]> GenerateEmbeddingAsync(string text)
        {
            var embeddings = await GenerateBatchEmbeddingsAsync(new List<string> { text });
            return embeddings.First();
        }

        public async Task<List<float[]>> GenerateBatchEmbeddingsAsync(List<string> texts)
        {
            _logger.LogInformation("Generating embeddings for {Count} texts", texts.Count);

            var request = new EmbeddingRequest
            {
                Input = texts,
                Model = _model
            };

            var response = await _client.CreateEmbeddingAsync(request);

            return response.Data
                .OrderBy(e => e.Index)
                .Select(e => e.Embedding.ToArray())
                .ToList();
        }
    }
}
```

**Key benefits vs local:**

- Немає налаштування часу запуску ONNX
- Немає управління пам 'яттю GPU
- Автоматичний байтинг від OpenAI
- Статус-зM SK1сМSK2арт. якості вмонтування

**Ціна**МSK0 ~$0.0001 за МSK2 К-потівки (очень дешевіM SK4

- Обробка блогових постів 100
- щоденне використання (10 запитиM SK1 ~$0.001/день МSK3 \$0.30/місяця

#### 2. Usługа Cloud LLM

```csharp
using Anthropic.SDK;
using Anthropic.SDK.Messaging;

namespace BlogRAG.Services
{
    public interface ILLMService
    {
        Task<string> GenerateCompletionAsync(
            string systemPrompt,
            string userPrompt,
            float temperature = 0.7f);

        IAsyncEnumerable<string> GenerateStreamingCompletionAsync(
            string systemPrompt,
            string userPrompt,
            float temperature = 0.7f);
    }

    public class ClaudeLLMService : ILLMService
    {
        private readonly AnthropicClient _client;
        private readonly string _model;
        private readonly ILogger<ClaudeLLMService> _logger;

        public ClaudeLLMService(
            string apiKey,
            string model,
            ILogger<ClaudeLLMService> logger)
        {
            _client = new AnthropicClient(new APIAuthentication(apiKey));
            _model = model;
            _logger = logger;
        }

        public async Task<string> GenerateCompletionAsync(
            string systemPrompt,
            string userPrompt,
            float temperature = 0.7f)
        {
            _logger.LogInformation("Generating completion with temperature {Temp}", temperature);

            var messages = new List<Message>
            {
                new Message
                {
                    Role = RoleType.User,
                    Content = userPrompt
                }
            };

            var request = new MessageRequest
            {
                Model = _model,
                MaxTokens = 2048,
                Temperature = temperature,
                System = systemPrompt,
                Messages = messages
            };

            var response = await _client.Messages.CreateAsync(request);

            return response.Content.First().Text;
        }

        public async IAsyncEnumerable<string> GenerateStreamingCompletionAsync(
            string systemPrompt,
            string userPrompt,
            float temperature = 0.7f)
        {
            var messages = new List<Message>
            {
                new Message { Role = RoleType.User, Content = userPrompt }
            };

            var request = new MessageRequest
            {
                Model = _model,
                MaxTokens = 2048,
                Temperature = temperature,
                System = systemPrompt,
                Messages = messages,
                Stream = true
            };

            await foreach (var chunk in _client.Messages.StreamAsync(request))
            {
                if (chunk.Delta?.Text != null)
                {
                    yield return chunk.Delta.Text;
                }
            }
        }
    }
}
```

**Прибутки від локального сектору**

- Немає завантаження моделі (instant startup)
- Немає обмежень VRAM (используйте 200K контекст, якщо потрібноM SK2
- Кращий результат. ( принаймні в теорії.
- Стримування працює ідеально

**Ціна**:

- Клод 3.5 Sonnet МSK1 МSK2мільйон входних टोकенів ,
- Типова сеанс написання блогу (20K введенняM SK1 2K виведенняМSK3 приблизно МSK4
- щомісяця

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

#### 3. Qdrant Vector Store Samе як у оригінальному variantіM SK2

```csharp
using Qdrant.Client;
using Qdrant.Client.Grpc;

namespace BlogRAG.Services
{
    public class QdrantVectorStore
    {
        private readonly QdrantClient _client;
        private readonly string _collectionName;
        private readonly ILogger<QdrantVectorStore> _logger;

        public QdrantVectorStore(
            string url,
            string apiKey,
            string collectionName,
            ILogger<QdrantVectorStore> logger)
        {
            _client = new QdrantClient(url, apiKey: apiKey);
            _collectionName = collectionName;
            _logger = logger;
        }

        public async Task CreateCollectionAsync(int vectorSize)
        {
            var collections = await _client.ListCollectionsAsync();

            if (collections.Any(c => c.Name == _collectionName))
            {
                _logger.LogInformation("Collection {Name} already exists", _collectionName);
                return;
            }

            await _client.CreateCollectionAsync(
                collectionName: _collectionName,
                vectorsConfig: new VectorParams
                {
                    Size = (ulong)vectorSize,
                    Distance = Distance.Cosine
                });

            _logger.LogInformation("Created collection {Name}", _collectionName);
        }

        public async Task UpsertAsync(
            Guid id,
            float[] vector,
            Dictionary<string, object> payload)
        {
            var point = new PointStruct
            {
                Id = id,
                Vectors = vector,
                Payload = payload
            };

            await _client.UpsertAsync(_collectionName, new[] { point });
        }

        public async Task<List<ScoredPoint>> SearchAsync(
            float[] queryVector,
            int limit = 10,
            float scoreThreshold = 0.7f)
        {
            var results = await _client.SearchAsync(
                collectionName: _collectionName,
                vector: queryVector,
                limit: (ulong)limit,
                scoreThreshold: scoreThreshold);

            return results.ToList();
        }
    }
}
```

**Те ж API, що й локальний налаштування** - зверніть увагу на локальний Докер чи Qdrant Cloud

### Трубопровод для впиту

```csharp
namespace BlogRAG.Services
{
    public class IngestionService
    {
        private readonly IEmbeddingService _embedder;
        private readonly QdrantVectorStore _vectorStore;
        private readonly ILogger<IngestionService> _logger;

        public IngestionService(
            IEmbeddingService embedder,
            QdrantVectorStore vectorStore,
            ILogger<IngestionService> logger)
        {
            _embedder = embedder;
            _vectorStore = vectorStore;
            _logger = logger;
        }

        public async Task IngestMarkdownFilesAsync(string markdownPath)
        {
            var files = Directory.GetFiles(markdownPath, "*.md", SearchOption.AllDirectories);
            _logger.LogInformation("Found {Count} markdown files", files.Length);

            foreach (var file in files)
            {
                await IngestFileAsync(file);
            }
        }

        private async Task IngestFileAsync(string filePath)
        {
            var content = await File.ReadAllTextAsync(filePath);
            var metadata = ExtractMetadata(content);
            var chunks = ChunkContent(content);

            _logger.LogInformation("Processing {File}: {ChunkCount} chunks",
                Path.GetFileName(filePath), chunks.Count);

            // Batch embedding generation
            var texts = chunks.Select(c => c.Text).ToList();
            var embeddings = await _embedder.GenerateBatchEmbeddingsAsync(texts);

            // Upload to Qdrant
            for (int i = 0; i < chunks.Count; i++)
            {
                var chunk = chunks[i];
                var embedding = embeddings[i];

                var payload = new Dictionary<string, object>
                {
                    ["text"] = chunk.Text,
                    ["file_path"] = filePath,
                    ["blog_post_slug"] = metadata.Slug,
                    ["blog_post_title"] = metadata.Title,
                    ["chunk_index"] = i,
                    ["category"] = metadata.Category
                };

                await _vectorStore.UpsertAsync(Guid.NewGuid(), embedding, payload);
            }

            _logger.LogInformation("Ingested {File}", Path.GetFileName(filePath));
        }

        private List<TextChunk> ChunkContent(string content, int chunkSize = 500, int overlap = 50)
        {
            // Simple sentence-aware chunking
            var sentences = content.Split(new[] { ". ", ".\n", "!\n", "?\n" },
                StringSplitOptions.RemoveEmptyEntries);

            var chunks = new List<TextChunk>();
            var currentChunk = new StringBuilder();
            var currentLength = 0;

            foreach (var sentence in sentences)
            {
                if (currentLength + sentence.Length > chunkSize && currentChunk.Length > 0)
                {
                    chunks.Add(new TextChunk { Text = currentChunk.ToString() });

                    // Overlap: keep last sentence
                    currentChunk.Clear();
                    currentLength = 0;
                }

                currentChunk.Append(sentence).Append(". ");
                currentLength += sentence.Length;
            }

            if (currentChunk.Length > 0)
            {
                chunks.Add(new TextChunk { Text = currentChunk.ToString() });
            }

            return chunks;
        }

        private BlogMetadata ExtractMetadata(string content)
        {
            // Extract from markdown frontmatter or HTML comments
            var titleMatch = Regex.Match(content, @"^#\s+(.+)$", RegexOptions.Multiline);
            var categoryMatch = Regex.Match(content, @"<!--category--\s+(.+)-->");

            return new BlogMetadata
            {
                Title = titleMatch.Success ? titleMatch.Groups[1].Value : "Untitled",
                Category = categoryMatch.Success ? categoryMatch.Groups[1].Value : "General",
                Slug = Path.GetFileNameWithoutExtension(content)
            };
        }
    }

    public class TextChunk
    {
        public string Text { get; set; } = string.Empty;
    }

    public class BlogMetadata
    {
        public string Title { get; set; } = string.Empty;
        public string Category { get; set; } = string.Empty;
        public string Slug { get; set; } = string.Empty;
    }
}
```

### Служба генерації РАГ

```csharp
namespace BlogRAG.Services
{
    public class RAGGenerationService
    {
        private readonly IEmbeddingService _embedder;
        private readonly QdrantVectorStore _vectorStore;
        private readonly ILLMService _llm;
        private readonly ILogger<RAGGenerationService> _logger;

        public RAGGenerationService(
            IEmbeddingService embedder,
            QdrantVectorStore vectorStore,
            ILLMService llm,
            ILogger<RAGGenerationService> logger)
        {
            _embedder = embedder;
            _vectorStore = vectorStore;
            _llm = llm;
            _logger = logger;
        }

        public async Task<string> GenerateSuggestionAsync(
            string currentDraft,
            string requestType = "continue")
        {
            // 1. Generate embedding for current draft
            var draftEmbedding = await _embedder.GenerateEmbeddingAsync(currentDraft);

            // 2. Search for relevant past content
            var results = await _vectorStore.SearchAsync(
                queryVector: draftEmbedding,
                limit: 5,
                scoreThreshold: 0.7f);

            _logger.LogInformation("Found {Count} relevant chunks", results.Count);

            // 3. Build context from results
            var contextBuilder = new StringBuilder();
            foreach (var result in results)
            {
                var text = result.Payload["text"].ToString();
                var title = result.Payload["blog_post_title"].ToString();
                var score = result.Score;

                contextBuilder.AppendLine($"## From: {title} (relevance: {score:F2})");
                contextBuilder.AppendLine(text);
                contextBuilder.AppendLine();
            }

            // 4. Build prompt
            var systemPrompt = BuildSystemPrompt(requestType);
            var userPrompt = BuildUserPrompt(currentDraft, contextBuilder.ToString(), requestType);

            // 5. Generate with LLM
            var suggestion = await _llm.GenerateCompletionAsync(
                systemPrompt: systemPrompt,
                userPrompt: userPrompt,
                temperature: 0.7f);

            return suggestion;
        }

        private string BuildSystemPrompt(string requestType)
        {
            return requestType switch
            {
                "continue" => @"You are a technical blog writing assistant. Your role is to suggest
                    continuations for blog posts based on the author's past writing style and content.

                    Guidelines:
                    - Match the author's voice and technical depth
                    - Use similar patterns and structures from past posts
                    - Be specific and technical, not generic
                    - Include code examples when relevant
                    - Maintain consistency with past content",

                "improve" => @"You are a technical blog editor. Your role is to improve sections
                    of blog posts while maintaining the author's voice.

                    Guidelines:
                    - Preserve the author's style
                    - Improve clarity and flow
                    - Add technical depth where appropriate
                    - Suggest better examples from past posts
                    - Fix unclear explanations",

                "outline" => @"You are a technical blog outline generator. Your role is to suggest
                    outlines for new blog posts based on past structures.

                    Guidelines:
                    - Study the author's typical post structure
                    - Suggest sections based on successful past posts
                    - Include technical depth appropriate to topic
                    - Reference similar past articles",

                _ => "You are a helpful technical writing assistant."
            };
        }

        private string BuildUserPrompt(string currentDraft, string context, string requestType)
        {
            return $@"
# Current Draft
{currentDraft}

# Relevant Past Content
{context}

# Request
{GetRequestDescription(requestType)}

Please provide your suggestion based on the current draft and the relevant past content shown above.
Remember to maintain consistency with the author's past writing style and technical approach.
";
        }

        private string GetRequestDescription(string requestType)
        {
            return requestType switch
            {
                "continue" => "Continue writing from where the draft ends. Suggest the next 1-2 paragraphs.",
                "improve" => "Improve the current draft. Suggest specific edits and enhancements.",
                "outline" => "Create a detailed outline for completing this post.",
                _ => "Provide helpful suggestions."
            };
        }
    }
}
```

## Простій Консольний Client

```csharp
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace BlogRAG.Console
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Setup DI and configuration
            var services = new ServiceCollection();

            var configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .AddUserSecrets<Program>()  // For API keys
                .Build();

            services.AddLogging(builder => builder.AddConsole());

            // Register services
            var embeddingConfig = configuration.GetSection("BlogRAG:Embedding");
            services.AddSingleton<IEmbeddingService>(sp =>
                new OpenAIEmbeddingService(
                    embeddingConfig["ApiKey"]!,
                    embeddingConfig["Model"]!,
                    sp.GetRequiredService<ILogger<OpenAIEmbeddingService>>()));

            var llmConfig = configuration.GetSection("BlogRAG:LLM");
            services.AddSingleton<ILLMService>(sp =>
                new ClaudeLLMService(
                    llmConfig["ApiKey"]!,
                    llmConfig["Model"]!,
                    sp.GetRequiredService<ILogger<ClaudeLLMService>>()));

            var vectorConfig = configuration.GetSection("BlogRAG:VectorStore");
            services.AddSingleton(sp =>
                new QdrantVectorStore(
                    vectorConfig["Url"]!,
                    vectorConfig["ApiKey"] ?? "",
                    vectorConfig["CollectionName"]!,
                    sp.GetRequiredService<ILogger<QdrantVectorStore>>()));

            services.AddSingleton<IngestionService>();
            services.AddSingleton<RAGGenerationService>();

            var serviceProvider = services.BuildServiceProvider();

            // Run CLI
            await RunCLI(serviceProvider, configuration);
        }

        static async Task RunCLI(ServiceProvider serviceProvider, IConfiguration configuration)
        {
            System.Console.WriteLine("=== Blog RAG Assistant ===\n");
            System.Console.WriteLine("Commands:");
            System.Console.WriteLine("  ingest - Ingest markdown files");
            System.Console.WriteLine("  write - Start writing session");
            System.Console.WriteLine("  quit - Exit\n");

            while (true)
            {
                System.Console.Write("> ");
                var command = System.Console.ReadLine()?.Trim().ToLower();

                switch (command)
                {
                    case "ingest":
                        await IngestCommand(serviceProvider, configuration);
                        break;
                    case "write":
                        await WriteCommand(serviceProvider);
                        break;
                    case "quit":
                        return;
                    default:
                        System.Console.WriteLine("Unknown command");
                        break;
                }
            }
        }

        static async Task IngestCommand(ServiceProvider serviceProvider, IConfiguration configuration)
        {
            var ingestion = serviceProvider.GetRequiredService<IngestionService>();
            var markdownPath = configuration["BlogRAG:Ingestion:MarkdownPath"];

            System.Console.WriteLine($"Ingesting from {markdownPath}...");
            await ingestion.IngestMarkdownFilesAsync(markdownPath!);
            System.Console.WriteLine("Ingestion complete!\n");
        }

        static async Task WriteCommand(ServiceProvider serviceProvider)
        {
            var rag = serviceProvider.GetRequiredService<RAGGenerationService>();

            System.Console.WriteLine("\nEnter your draft (end with empty line):");
            var draft = new StringBuilder();
            string? line;

            while (!string.IsNullOrWhiteSpace(line = System.Console.ReadLine()))
            {
                draft.AppendLine(line);
            }

            System.Console.WriteLine("\nGenerating suggestion...\n");
            var suggestion = await rag.GenerateSuggestionAsync(draft.ToString());

            System.Console.WriteLine("=== Suggestion ===");
            System.Console.WriteLine(suggestion);
            System.Console.WriteLine("\n");
        }
    }
}
```

## Працюючи в системі

### Установлення першого разу

```bash
# 1. Clone/create project
dotnet new console -n BlogRAG
cd BlogRAG

# 2. Add packages
dotnet add package Qdrant.Client
dotnet add package OpenAI
dotnet add package Anthropic.SDK
dotnet add package Microsoft.Extensions.Configuration.Json
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

# 3. Set API keys (stored securely)
dotnet user-secrets init
dotnet user-secrets set "BlogRAG:Embedding:ApiKey" "sk-..."
dotnet user-secrets set "BlogRAG:LLM:ApiKey" "sk-ant-..."

# 4. Start Qdrant (local)
docker run -d -p 6333:6333 qdrant/qdrant

# 5. Run ingestion
dotnet run
> ingest

# 6. Start writing
> write
```

**Весь час налагодження**МSK0 приблизно 15 хвилини проти приблизно ♫ 2 ♫ годин для локального налаштування GPU ♫ МSK3 ♫ припущення, що все йде гладко ♫ ♫МSK4 ♫ що, з мого досвіду, є небезпечним припущенням ♫

### Щодня

```bash
# Start Qdrant (if using local Docker)
docker start qdrant

# Run assistant
dotnet run
> write

# Enter your draft
I've been working on a new feature that uses Entity Framework Core...
[Ctrl+D or empty line]

# Get AI suggestion based on your past EF posts!
```

## Розробка витрат

### Monthly Cost Estimate (Personal BlogM SK1

**сценарій**: Письмо на блогі МSK1 за місяць

МSK0 Операція | Об 'єм МSK2 Koszt |
|-----------|--------|------|
| Початкова поглинання
| Помешкання МSK1запросиМСК2 МСК3місячніМ СК4 | | 5 | 6 | टोकони | 7 | 8 | 9 |
| LLM телефонні дзвінки (40 запропонування
| **Щомісяця** | | **~$3.65** |

**Для порівняння:**

- Локальне налаштування: M SK1місяця (но МSK3 GPU в передній плані)
- ChatGPT Plus: M SK1місяця (не РАG, генеральнийMSC4
- Премія Grammarly Premium: M SK1місяця (без штучного письма)

**Перерізок-десята точка**: Якщо виM SK1 будете використовувати це на МSK2 місяці МSK3 локальна графічна комп 'ютера плати сама за себе . В противном випадку, хмара дешевша M SK6 Хоча яMSC7 все ще працюю над тим, чи мої прогнози затрат є точными М SK8 Я можу поїсти мої слова через кілька місяців, коли будуть рахунки в МSK9

### Наполегшення оптимізації витрат

1. **Використовувати менші моделі для вмонтування**:
   
   - `text-embedding-3-small`МSK0 $0.00002/1К टोकен
   - `text-embedding-3-large`МSK0 $0.00013/1К टोकен
   - 6.5x різниця в вартостіM SK1

2. **Виклики пакету API** (50% дешевше для неможливих
   
   ```csharp
   // Use OpenAI Batch API for ingestion
   var batch = await client.CreateBatchAsync(requests);
   // Wait hours, pay half price
   ```

3. **Поміщання в кэш локально**:
   
   ```csharp
   // Don't re-embed identical text
   var cache = new Dictionary<string, float[]>();
   ```

4. **Використовуйте дешевші моделі для креслень**:
   
   - Claude 3.5 Haiku : МSK2 Введення МSK3 x дешевше, ніж Sonnet
   - МSK4x дешевше, ніж -4)

5. **Лімінувати вікно контексту**:
   
   ```csharp
   // Retrieve top 3 instead of top 10 chunks
   limit: 3  // 70% less input tokens
   ```

## Взаємні переваги від локального налаштування

### 1. Краще якість моделі

| Модель МSK1 Контекст МSK2 Якість | Локальна MSК4 МСК5 Хмара СМСК6 СМСК7
|-------|---------|---------|--------|--------|
| Містраль МSK1B МSK2 мSK3K | Хороший M| Так МСК6потрібні МНSK7ГБ оперативної пам 'яті
МSK0 Ллама 3 MSК2B МСК3 | | 4 | 5 | Чудово | 6 | Ні | 7 | потреби | 8 | GB VRAM | 9 | 10 | Так | 11 |
МSK0 ГПЗ-4 Турбо M SK2 МSK3K | Отож, відмінно MSК5 Ні МСК6 Так MSК7
МSK0 Клод 3.5 Сонет МSK2 200K MSК4 Найкращий МСК5 Ні СМСК6 Так СМСК7

**хмара дає вам доступ до моделей 70BM SK1** що потребуватиме $10KM SK1 Ґуґвидовий апарат МSK2 Принаймні МSK3 що ' це теорія \ - Я \ МSK6 я все ще вивчаю, чи більші моделі насправді виробляють помітно кращий зміст блога в praktyce \.

### 2. миттєві aktualiзації

```csharp
// Switch models with one line
services.AddSingleton<ILLMService>(sp =>
    new ClaudeLLMService(  // Was GPT-4, now Claude
        config["ApiKey"],
        "claude-3-5-sonnet-20241022",  // Latest model
        sp.GetRequiredService<ILogger<ClaudeLLMService>>()));
```

**Ніхто не завантажує моделі**, без конверцій GGUF , без перевірок комп 'ютерної здатності МSK2 Це дійсно блискуче, коли виM SK3 експериментуєте з різними моделями, щоб побачити, що працює найкраще .

### 3. КроссM SK1Platформа

```bash
# Works on Mac (no CUDA support)
dotnet run  # Just works!

# Works on Linux ARM (Raspberry Pi?)
dotnet run  # Just works!

# Works in Codespaces/Gitpod
dotnet run  # Just works!
```

**Місцевий підхід - Windows + NVIDIA тільки .**

### 4. Скалабельність

```csharp
// Handle 100 concurrent users? Easy with APIs
await Task.WhenAll(users.Select(u =>
    rag.GenerateSuggestionAsync(u.Draft)));

// Local? Limited by your single GPU
```

### 5. Простіше застосування

```bash
# Deploy to Azure/AWS/GCP
dotnet publish -c Release
# Upload single binary, set env vars, done

# Local? Need to:
# - Include 12GB model files
# - Install CUDA on target machine
# - Ensure GPU drivers
# - Manage VRAM
```

## Ограничення & Торгівля МSK1Офф

### 1. Занепокоєння щодо приватності

**Содержание вашого блогу йде до OpenAI/Anthropic.**

Полегшення:

- Тільки для публічного контенту блогів
- Проверьте політику використання даних провайдера '
- Дані API OpenAI: не використовуються для навчання ( як МSK2
- Антропічний: Те ж саме

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

### 2. Залежність від мережі

**Без Інтернету = без помічникаM SK1**

Полегшення:

- Захищати попередні ідеї локально
- Втілити режим відключення для редагування
- Поверніться до менших локальних моделей

### 3. Тривалість

**Виклики API займають 1-3 секунду порівняно з МSK1с локальноM SK2**

Перевірка реальності:

- Покоління локального: M SK1
- Покоління хмар: M SK1
- Різниця

### 4. Маршрутизатор

**Перемикання API вимагає змін коду.**

Полегшення:

```csharp
// Use abstraction layer
public interface ILLMService
{
    // Switch providers easily
}

// Factory pattern
services.AddSingleton<ILLMService>(sp =>
{
    return config["Provider"] switch
    {
        "OpenAI" => new OpenAILLMService(...),
        "Anthropic" => new ClaudeLLMService(...),
        "Cohere" => new CohereLLMService(...),
        _ => throw new Exception("Unknown provider")
    };
});
```

## Гібридний підхід: Найкращий з обох світів

**Чи можна поєднати локальну і хмару?** Absolutely!

```csharp
public class HybridEmbeddingService : IEmbeddingService
{
    private readonly LocalOnnxEmbedding _local;
    private readonly OpenAIEmbeddingService _cloud;
    private readonly bool _preferLocal;

    public async Task<float[]> GenerateEmbeddingAsync(string text)
    {
        if (_preferLocal && _local.IsAvailable())
        {
            return _local.GenerateEmbedding(text);  // Free, fast
        }

        return await _cloud.GenerateEmbeddingAsync(text);  // Fallback
    }
}
```

**Використовуйте локальний для вмонтування. (швидкий, швидкийM SK2 хмара для LLM**:

- Поміщання локально МСК0 Заощадити МSK1місяця (маленька сума, визволеноM SK4
- LLM в хмарі: Получить GPT-4/Качество Клода

Це насправді мій **запропонований підхід**МСК0 хоча я ' досі експериментую, щоб перевірити, чи це - правильний баланс

1. Використовувати маленьку модель вмонтування локально (непотрібно GPU)
2. Використовувати хмарні API для LLM
3. Qdrant локальний для розвитку, хмара для виробництва

## Завершення

Альтернатива хмари для " Адвоката GPTM SK1 дає вам приблизно МSK2 переваги з МSK3 складності - або, принаймні, те, що

| Функція МSK1 локальний МSK2 Хмара |
|---------|-------|-------|
| Час набору МSK1 МSK2 години мSK3 ♫ ♫ МSK4 ♫ хвилини ♫ | ♫
| Hardware requirement | NVIDIA GPU МSK2 Будь-який комп 'ютер МSK3
МСК0 Якість моделі | МSK2BM SK3B | GPT-4, Claude MSК6 \|
| щомісяця вартість МSK1 МSK2 \| приблизно
МSK0 Тривалість | МSK2s | ♫ ♫
| Prywatність МSK1 МSK2 локальний | Посилається до APIs M|
| Кроссіальний МSK1платформа МSK2 лише Windows
| Утримка МSK1 Обновлення моделейM SK2 Обновиння стандарту CUDA | Нічого МSK4

**Коли використовувати хмару:**

- Ви не маєте NVIDIA GPU
- Ви на Mac
- Ви хочете найпростіший шлях
- Ви пишете менше ніж 10 постівM SK1місяця
- Ви довіряєте провайдерам хмар з публічним контентом

**Коли використовувати локальний:**

- У вас є мікросхема
- Приватність є вирішальним
- Ви хочете $0 операційні витрати
- Ви написали більше, ніж 20 записиM SK1місяця
- Ви насолоджуєтеся tinkeringом

**Найкращий підхід:** Почнемо з хмари. Якщо вам сподобається і вдасться заплатити за неїM SK1 обмеження конфіденциальності , мігрувати на локальну платформу пізніше МSK3 архітектура RAG ідентична M SK4 ви просто перезамінюєте LLM-сервіс ! Хоча я мушу зауважити, що я ' я все ще вивчаю тут купівлю

## Наступні кроки

1. **Спробуйте**: Установіть хмарну версію сьогодні ввечері
2. **Інгест**: Обробка ваших блогових постів
3. **Написати**: Получите поради з штучного інтелекту на основі вашого минулого контенту
4. **Вимір**: Nákladи та корисність траси
5. **Визначати**: Залишити хмару або мігрувати на локальну

Краса РАГ - **Ви не заблоковані**. Вektorна база данихM SK1 відокремлення, і логіка пошуку працюють однаково, незалежно від того, чи ваш LLM є на вашій GPU або в OpenAI

Почнемо з простого, докажи цінністьM SK1 потім оптимізуймо. Я ' я досі вивчаю, що працює найкраще самі собою

## Ресурс

### Подібні статті

- [Оригинальный юрист Серія GPT ( Частина МSK1](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- [RAG пояснив: (АнтропічнийM SK1](/blog/building-a-lawyer-gpt-for-your-blog-part1)

### Наrzędziа & Usługи

- [Кдрант](https://qdrant.tech/) База даних вектора -
- [Хмара Qdrant](https://cloud.qdrant.io) - Managed hosting
- [Платформа OpenAI](https://platform.openai.com)
- [Антропічна консоль](https://console.anthropic.com)
- [OpenAI .NET SDK](https://github.com/openai/openai-dotnet)
- [Антропічний .NET SDK](https://github.com/tghamm/Anthropic.SDK)

### Код

- Полний приклад коду: [Репозиторія GitHub] (наближається !)

Щасливе письмо з вашою хмарою-вправний штучний інтелект