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

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

AI C# Cloud LLM OpenAI Qdrant RAG

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

Wednesday, 12 November 2025

Введение

У моєму 8-частина МSK1 Адвокат GPTM SK2 серії, Я показав вам, як побудувати повний локальний 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: Це частина моїх експериментів з штучним інтелектом

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

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

Полна серія "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

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

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

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

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
  2. Створити безкоштовний кластер
  3. Візьміть ваш API ключ і кластер URL

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

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

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

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

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

  1. Перейти до konsol.anthropic.com
  2. Створити API ключ

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

Створити appsettings.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

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

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

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

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

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, @"");

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

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

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

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

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

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

# 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 ♫ що, з мого досвіду, є небезпечним припущенням ♫

Щодня

# 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% дешевше для неможливих

    // Use OpenAI Batch API for ingestion
    var batch = await client.CreateBatchAsync(requests);
    // Wait hours, pay half price
    
  3. Поміщання в кэш локально:

    // Don't re-embed identical text
    var cache = new Dictionary<string, float[]>();
    
  4. Використовуйте дешевші моделі для креслень:

    • Claude 3.5 Haiku : МSK2 Введення МSK3 x дешевше, ніж Sonnet
    • МSK4x дешевше, ніж -4)
  5. Лімінувати вікно контексту:

    // 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зації

// 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форма

# 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. Скалабельність

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

// Local? Limited by your single GPU

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

# 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 вимагає змін коду.

Полегшення:

// 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!

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 потім оптимізуймо. Я ' я досі вивчаю, що працює найкраще самі собою

Ресурс

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

Наrzędziа & Usługи

Код

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

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

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.