Inleiding

Kliv in eftersom det kommer att bli en lång serie.!, om du har följt med den här bloggen, ,, så kommer du att veta att jag är lite besatt av att hitta intressanta sätt att använda LLM och AI i praktiska tillämpningar.

NOTET: Det här är en del av mina experiment med AI ( assisterad redigering ) + mitt eget redigerande M SK4 Samma röst, , samma pragmatism,; bara snabbare fingrar

Tänk på hur moderna rättspraktiker använder jurister som är tränade i rättspraxis för att skriva ut anteckningar, , motioner , och kontrakt . De börjar inte från början - systemet refererar till relevanta tidigare exempel , föreslår språk baserat på framgångsrika tidigare dokument , och upprätthåller en jämlikhet med etablerade mönster . Det är precis vad vi bygger här' men för blogginnehåll .

Målet är att skapa en AI-assistant för skrift som

• Det hjälper att skapa nya bloggar i min etablerade stil
• Suggererar relevanta innehåll från tidigare artiklar att referera till
• finner liknande poster för att bibehålla jämlikhet
• Auto-genererar inre länkar till besläktade artiklar
• Akter som "GitHub Copilot för din blogg

Den här serien handlar om att bygga en komplett Retrieval-upgraderad generation (RAGM SK1 system i C, som funkar på Windows, . Vi använder de senaste tillvägagångssätten och ramarna, , och I, och ' förklarar varje ny teknik när vi möter den.

Min hårdvarauppsättning ( och minimala specifikationer)

Min utvecklingsmaskin:

• GPU: NVIDIA RTX A
• CPU: AMD Ryzen
• RAM: 96GB DDR

Det här är min specifika konfiguration, men du don' behöver inte denna hårdvara att följa längs med. Här är de minsta specifikationerna för olika komponenter :

GPU: s accelerering ( Empfohlend , inte nödvändigt

• Minimum: NVIDIA GPU med
  • Kan köra 7B-parametermodeller med kvantisering
  • Noggrann embeddingskapande hastighet
• bekvämt: 12GB+ VRAM (eM SK4g+., RTX
  • Runna större modeller eller bättre kvantiseringar
• Min inställning: 16GB (A4000) | | 4 | Kan köra | 13 | B modeller bekvämt

CPU- Bara alternativ

• Minimum: Modern kvad-core CPU
• Recommended:
• Allt fungerar på CPU
  • Embedding generation: ~5-10x långsammare
  • LLM-förklaringen: ~10-50x långsammare
  • Ännu helt användbar för en skrivassistent!

Rambehov

• Minimum: 16GB system RAM
  • CPU- endast slutsats för 7B-modeller
• bekvämt: 32GB
  • Bättre för större modeller på CPU
• Min inställning: 96 GB

Storage

• SSD: Recommended for model loading
• Rymden: ~20GB för modeller och vektordatabas

Vad sägs om Intel/AMD NPUs

Moderna CPUs innehåller nu dedikerade AI-acceleratorer:

• Intel Core Ultra (Meteor Lake
• AMD Ryzen AI (7040/8040 serie
• AMD Ryzen AI Max (Strixpunkt) - upp till 50 TOPS

viktigt: NPUs är bara till att dra slutsatser Ni kan inte bygga ', " eller tågmodeller på NPUs. De är designade för springa pre- tränade modeller effektivt . Modeller är tränade på moln-GPUs | ( | eller arbetsstationer |), | sedan laddade ner och deployerade till NPUs för gissning

Den nuvarande statusen för drivna modeller på NPUs (eftersom jag skriver):

• ✅ Bra för
• ⚠️ Begränsat för vårt användande: Oändligt .NETM SK3ONNX Runtime support
• ❌ Inte redo för: Det här projektets primära väg

Varför inte NPUs för denna serie?

1. mjukvara ekosystem: CUDA har 15+ år av maturitet
2. Modellkompatibilitet: De flesta GGUF-modeller riktar sig mot CUDA/CPUM SK2 NPU -Optimerade modeller är sällsynta
3. Dokumentation: begränsade resurser för NPU-utveckling i C
4. Förmågor: Ännu långsammare än diskreta GPUs för vår arbetslast
5. DirectML-stöd: Experimentell för LLM-förklaring

Kan du använda NPUs för att dra slutsatser?

• Erfordrar DirectML execution provider i ONNX Runtime
• Modeller måste vara i ONNX format ( inte GGUF)
• C# stöd är experimentellt
• Resultaten är i dagsläget underväldigande jämfört med

Hur man prövar NPU-förklaringen (advanced users):

# Use DirectML execution provider (supports NPU)
dotnet add package Microsoft.ML.OnnxRuntime.DirectML

# In code:
var sessionOptions = new SessionOptions();
sessionOptions.AppendExecutionProvider("DML"); // DirectML
var session = new InferenceSession("model.onnx", sessionOptions);

Framtidens övervägande: En gång Runtime på ONNX och DirectML mogna deras NPU-stöd ( antagligen | 2024-2025), | dessa kommer att bli livsviktiga alternativ för gissning

Bottomlinen: I' kommer visa GPU: n - accelererad väg M SK3 men kommer lägga märke till CPU - endast alternativ över hela sträcket Mska5 Du kan starta CPUMska6 endast och uppgradera senare M Ska7

Vad vi bygger

Det slutgiltiga systemet kommer att ha flera komponenter

1. Markdown Ingestion Pipeline - Processar alla bloggare meddelanden , hamnar dem intelligenta chunks, , och genererar inbäddar
2. Vektordatabas - Speicherar inbäddar och låter semantiskt söka efter liknande innehåll
3. Windows Client Applikation - En datorskrivareassistent med redigering och förslagspanel
4. LLM integrering - Lokal GPU- accelererad inferens för innehållsgenerering
5. Citation & Link generation - Auto - antyder inre länkar och referenser till förknippade positioner
6. Stylekonsistensmotor - lär sig mönster från existerande postituser för att behålla röst och struktur

Tänk på det som "GitHub Copilot möter Grammarly " men har tränats specifikt på din blogg

Varför " advokat GPT"?

Moderna advokat kontor använder LLM-arbetare som är utbildade i stora oikeusbibliotek för att hjälpa till att skriva lagdokument.

• Referenser till relevanta precedenter och tidigare framgångsrika argument
• Suggererar språkmönster som har fungerat förut
• Håller med lagstiftningsnormerna
• Citer källor automatiskt

Det är vår modell. När jag börjar skriva: """, "" Att lägga till enhetens ram "" för "...",", så borde systemet:

• Hitta mina tidigare EF--relaterade postituser
• Suggest strukturella mönster som jag har använt tidigare
• Ge relevanta kodsnippet från tidigare artiklar
• Auto-generera länkar till besläktade postituser
• Att upprätthålla min skriftstil och teknisk djup

Till skillnad från generiska AI-skrivare-assistenter, är vårt system grundat i det faktiska förflutna innehållet.

Serie Übersicht

Här är vad vi kommer att bevaka under de kommande veckorna.

Del 1 (Det här постet): Inleiding & Arkitektur

Vi kommer att definiera vad vi bygger och varför vi gör det plus de arkitektoniska besluten.

Del 2: GPU Setup & CUDA i C#

Att sätta upp Windows för GPU-accelerated AI workloads, installering CUDA, cuDNN, och testar att C# faktiskt kan se och använda din GPU

Del 3: Understanding Embeddings | & | Vektordatabaser

Ta djupt in i vad inbäddar egentligen är, hur de gör det möjligt att göra semantiskt sök, , och välja den rätta vektordatabasen. Qdrant eller pgvector).

Del 4: Byggnaden av införingsledning

Att bearbeta markerdown-filer, intelligenta skräddarsstrategier | ( | kan du ' | inte bara dela på paragrafer ♫ !), | och generera inbäddar för alla våra innehåll ♫

Del 5: Windows Client

Att välja rätt ramverk (WPF, Avalonia, eller MAUI?), att bygga upp gränssnittet , och göra det faktiskt bekvämt att använda

Del 6: Lokal LLM integration

Att köra modeller lokalt med Runtime på ONNX, llama.cpp bindningar, eller andra angreppssätt

Del 7: innehållsgenerering & Vinniga ingenjörskonst

Att sammanföra allting - semantisk sökande efter relevant innehåll , kontextuellt fönster som sköts i, snabb ingenjörskonst för att skriva hjälpen

Del 8: Utvecklade egenskaper & Tillverkning av produktion

Automatiskt- länka till besläktade poster , stylekonsistenskontroll, , kodsnippet förslag, , och göra systemet faktiskt användbart för vardaglig skrift

Varför RAG?

Innan vi dyker in i arkitekturen, låt oss tala om varför RAG, (, Retrieval Augmented Generation och ) är rätt tillvägagångssättet.

Problemet med Fine-Tuning

Du kanske tänker: : " Varför inte bara bra?

1. kostnad & komplexitet - BraM SK1 Anpassning är dyrt både i beräkning och ansträngning
2. Stallhet - Varje ny bloggpost betyder omvandling
3. Den svarta lådan - svårt att förstå vad modellen lärt sig
4. Hallucinationer - Ingen garantera för att modellen kommer att vinna
5. Inga Citationer - Kan ' inte lätt spåra svar tillbaka till källorna

Hur RAG löser detta

RAG kombinerar det bästa av båda världarna: kraften hos LLMs med precision i sökandet för att skapa kontext

Flöden är:

1. Användaren börjar skriva: (eM SK1g., | | " | Att bygga en REST API med ASP
2. System hittar semantiskt liknande tidigare artiklar
3. System matar in relevanta bitar som kontext till LLM
4. LLM genererar förslag, /, fortsättningar baserat på tidigare innehåll
5. Systemet erbjuder förslag med referenser till källposter

Detta betyder:

• ✅ alltid uppe-tillM SK2datum (just redigera new posts as du skriver dem
• ✅ grundat i ditt faktiska skriv ( upprätthåller konsistens
• ✅ spårbar ( vet vilka föregående postituser påverkade förslaget
• ✅ Effektiv ( ingen dyr omsättning för varje ny anställning
• ✅ Flexibel ( kan byta ut LLM eller justera sökstrategier
• ✅ Privatsphäre

Systemarkitekturen

Låt mig bryta ner de viktigaste komponenterna som vi ska bygga

graph TB
    A[Markdown Files] -->|Ingest| B[Chunking Service]
    B -->|Text Chunks| C[Embedding Model]
    C -->|Vectors| D[Vector Database]

    E[User Writing] -->|Current Draft| F[Windows 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[Local LLM]
    I -->|Generated Suggestions| J[Link Generator]
    J -->|Suggestions + Citations| F

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

    class C,I embedding
    class D,K output

    classDef embedding stroke:#333,stroke-width:4px
    classDef output stroke:#333,stroke-width:4px

1. Markdown Ingestion Pipeline

Denna komponent:

• läser markerdown-filer från bloggkatalogen
• Extraherar metadata ( titel , kategorier, datumM SK3 ordtal
• Intelligent killrar innehållet (bevara kodblock för återanvändning
• Identifiserar strukturella mönster ( hur jag organiserar jobb
• Träger källinformation för citationsgenerering

Nyckelutmaningen: Spelningsstrategin spelar en enorm roll . Alltför liten och du förlorar kontexten M SK2 Allt för stor och du slösar bort LLMs kontextfenster ' vi behöver fragment som är semantiskt meningsfulla MSC5 en komplett tanke eller sektion

2. Embedding-modell

Embedding är magin som gör det semantiska söket att fungera.

Samma koncept hamnar i: "schließa " i vektorn

Till exempel:

• "databas migration" och "uppdatering av DB-schematenM SK3 skulle ha liknande inbäddar
• "katt, " och "kytten, M SK3 skulle vara närmare än databasen.

Teknologins val: Vi ' kommer troligen att använda antingen

• mening-transformatorer modeller (kan köra genom ONNX Runtime i C#)
• OpenAI's inbäddade modeller (med hjälp av API
• BGE-modeller (, stat, -, av -, den -, artopen source, )

3. Vektordatabas

Den vektordatabasen lagrar inbäddar och gör det möjligt att bläddra efter likheter.

Teknologins val: Vi ' bedömer

• Qdrant - Moderna , skrivet i rött, utmärkt CM SK3 klientMST4 DockerM ST5vänlig
• pgvector - Utveckling för PostgreSQL
• Veva - En annan solid alternativ med bra .NET stöd
• Chroma - Beliebt på Python-landen , mindre så i CM SK2

I' vänder mig mot Qdrant för sin enkelhet och prestationsförmåga , eller pgvector för att hålla allting i Postgres

4. Windows Client

Vi behöver en bra gränssnitt för att skriva med hjälp av AI.

WPF (Windows Presentation Foundation

• ✅ mognad , stabilt M SK2 massor av resurser
• ✅ Enkela Windows-presterande
• ❌ bara Windows
• ❌ Ser daterad ut om du inte investerar i gränssnittbibliotek

Avalonia

• ✅ Cross
• ✅ Moderna , aktivt utvecklat
• ✅ liknande WPF
• ❌ Mindre ekosystem

MAUI (Multi

• ✅ Cross
• ✅ Microsoft
• ❌ Fortskridande
• ❌ Mer mobilt

Eftersom vi är fokuserade på Windows, så vill jag ha något stabilt. WPF med ModernWPF-gränssnitt eller Avalonia för den korsningen

5. Lokal LLM integration

Det är här som A4000 GPU lyser på

• Privatsphäre ( inga data skickad till API: n )
• Rymden (lokal inferens är snabbM SK1
• kostnaderna ( inga API-avgifter )
• Kontroll ( vi väljer modellen )

Teknikoptioner:

Runtime på ONNX

• Konvertera modeller till ONNX format
• Utmärkt GPU-acceleration
• C# moderstöd
• Bottomsidan: Alla modeller konverterar inte bra

llama.cpp bindningar

• C++ bibliotek med C # bindinger M SK2LLamaSharp)
• Ondersteuner CUDA
• bred modellstöd (Llama, MistralM SK2 och så vidare
• Väldigt aktivt utveckling

TorchSharp

• PyTorch-bindningar för .NET
• Större flexibilitet
• Steeper learning curve

I'clinerar mot LLamaSharp för sin mognad och enkelhet att använda med vanliga modeller.

6. Kontextfenster-Management & Vinniga ingenjörskonst

LLM har begränsade kontextfenster.

• Rekrytera den mest relevanta förflutna innehållet (top K från vektorsökningen)
• Passa dem in i kontextfenstern med den nuvarande ritningen
• Strukturera formeln för att skriva hjälp
• Släpp ut plats för genererade förslag

Det här är svårare än det låter.

• Dynamisk K-sellektion baserat på vad du skriver just nu
• Re--ranking av uppfunna chunks efter relevans
• Komprimera kontexten intelligent
• Multi-shot prompt med exempel från tidigare Beiträge

7. Link & Citationskapande

Varje chunk behöver metadata:

• källkod/post
• Position i originaldokumentet
• publicera datum
• Kategorier
• Kodbitarna som användes

När LLM genererar förslag, skapar vi automatiskt markerdown länkar till källposterna och identifierar återanvändbara kodmönster.

Vad gör det här annorlunda

Det finns många RAG-repetitioner där ute, men den här serien kommer vara annorlunda.

1. C# Först - De flesta RAG-exempler finns i Python. ViM SK2 går fulla .NET
2. Windows & GPU - Leveragera NVIDIA CUDA på Windows
3. Produktion redo - Inte bara beviset -av-föreställningen, utan också den faktiska användande koden
4. Domain- Spesifik - Optimiserad för hjälp när man skriver på en blogg
5. djupa förklaringar "Vi ska faktiskt förklara varför vi fattar besluten"

Tekniker som vi ska använda

Här är "'", den tekniska högen.

Kernframework

• .NET 9 (ste vid skrivandes tidpunkt
• C# 13 - Moderna språkdefinitioner

AI/ML Bibliotek

• Runtime på ONNX eller LLamaSharp - LLM-förklaring
• Microsoft.ML - För vissa uppgifter
• SentenceTransformers via ONNX - Embeddings

Vektordatabas

• Qdrant eller pgvector - Bestäms

UI: s ram

• WPF med ModernWPF eller Avalonia - Moderna datorgränssnitt

Ondersteunande verktyg

• Markdig - Du använder redan det här för markdown-analys
• Docker - För att köra Qdrant eller andra tjänster
• Enhetens ramskärna - Om vi använder pgvector

GPU-skivan

• CUDA 12.x (ste vid skrivandes tidpunkt
• cuDNN - Grundlekar för djupinlärning

Tillvägagångspunkter

Olika hårdvarauppsättningar kommer att ha olika egenskaper:

Med 8GB VRAM

• Modells storlek: 7B-parametermodeller med QM SK2 kvantisering
• Batchprocessing: Inbäddar i mindre lager
• Att sköta minnet: Att noggrann VRAM-monitoring krävs
• Fungerar bra för: skrivandeassistent , skapande av inbäddar

Med 12GBM SK1 VRAM (Komfortabel)

• Modells storlek: 7B med högre kvantiseringsgrad
• Batchprocessing: Större lager för snabbare genomspetsning
• Kan också köra: Några 13B-modeller med aggressiv kvantisering

Med 16GB+ VRAM | ( | Min konfiguration

• Modells storlek: 7BM SK2B parametermodeller bekvämt
• Batchprocessing: Full batches , minimala begränsningar
• snabb slutsats: Sub-timmar för att svara
• Chefrummet: Kan experimentera med olika modeller

CPU-Omnär (FallbackM SK2

• Allt fungerar, bara långsammare
• Embeddings: 5-10x långsammare än GPU
• LLM-förklaring: 10-50x långsammare än GPU
• Ännu ändå användbar: För en skrivare som har tålamod

Utvecklingssätt

Vi "'" ska bygga upp den i stegvis skala.

1. Börja med de enklaste komponenterna ( markerdown läsning , chunking)
2. Lägg till embedding generering ( skulle kunna börja med API-baserad innan det går till lokaltM SK2
3. få vektorsökningen att fungera
4. Att bygga grundläggande gränssnitt
5. Integrera LLM
6. Polska och optimera

Varje del kommer att vara användbar och testbar på egen hand.

Vad's Nästa?

I Del 2: GPU Setup & CUDA i C#, vi ' får händerna - med GPU-uppsättningen

• Att installera CUDA och cuDNN på Windows
• Att organisera utvecklingsmiljön
• Att skriva ett enkelt C# program för att kontrollera GPU: s tillgång
• Att köra en grundförklaringstest med ONNX Runtime
• Benchmarking av vår A4000 för att förstå vad vi kan göra

Det här kan verka grundläggande, men att få GPU-stecken rätt är avgörande.

Varför det här spelar roll

Förutom att bara vara ett häftigt projekt, så har denna metod verkliga tillämpningar.

• Teknikdokumentation - Att upprätthålla konsekvent stil över stora dokumentsamlingar
• Rättspraxis - verkligt användande fall
• Inhoudsmarketing - Att upprätthålla varumärkens röst över lag
• Akademik skrift - Konsistens med tidigare studier och forskning
• Personlig kunskapsmanagement - skrivassistent för ditt eget korpus

Principerna som vi kommer att tillämpa gäller alla områden där du har existerande innehåll och behöver upprätthålla konsistens när du skapar nya material.

Slutsatsen

Vi sätter igång på en resa för att bygga en produktion, -, kvaliterad RAG, -, som är baserad i C, som hjälper till att utveckla blogginhoud genom att använda tidigare artiklar som referensmaterial. -, precis som jurister använder LLMs som tränats i rättspraxis.

Det här är inget lekprojekt. Vi bygger något som verkligen kan vara användbart för alla som skriver regelbundet och vill upprätthålla konsistens. Stilen. , och kvaliteten över ett stort arbete.

I nästaပိုင်း kommer vi att göra våra händer smutsiga med CUDA, ,, GPU och , och se till att vår utvecklingsmiljö är redo för utmaningarna som väntar.

Bli uppkopplade, och förbereda dig på att lära dig om inbäddar , vektordatabaser, , skalningsstrategier,, snabbingenjörskonst,, och alla de andra fantastiska komplexiteten i moderna AI-system.

Seri Navigation

• Del 1: Inleiding & Arkitektur (this postM SK1
• Del 2: GPU Setup & CUDA i C#
• Del 3: Understanding Embeddings | & | Vektordatabaser
• Del 4: Byggnaden av införingsledning
• Del 5: Windows Client
• Del 6: Lokal LLM integration
• Del 7: innehållsgenerering & Vinniga ingenjörskonst
• Del 8: Utvecklade egenskaper & Tillverkning av produktion

resurser

Om du vill få en huvudstart, här är några resurser som jag kommer att referera till genom hela den här serien.

• Runtime Dokumentation
• LLamaSharp GitHub
• Qdrant Dokumentation
• Sanningtransformatorer
• Att förstå RAG-system

Se er i Del 2!