Back to "Costruire un "Avvocato GPT" per il tuo blog - Parte 1: Introduzione & Architettura"

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 AI-Article C# LLM mostlylucid.blogllm RAG

Costruire un "Avvocato GPT" per il tuo blog - Parte 1: Introduzione & Architettura

Wednesday, 12 November 2025

ATTENZIONE: Questi sono i progetti di POST che sono "scaparnati."

E 'probabile che gran parte di ciò che è qui sotto non funzionerà; Io generare questi come come come-per me e poi fare tutti i passi e ottenere il campione di lavoro app ... Sei stato subdolo e li hai visti! saranno probabilmente pronti a metà dicembre.

## Introduzione

Allaccia la cintura perche' sara' una lunga serie!

Se hai seguito questo blog, saprai che sono un po' ossessionato dal trovare modi interessanti per usare LLM e AI in applicazioni pratiche.

Bene, ho un nuovo progetto che unisce il mio amore per il blogging, C#, e AI: la costruzione di un assistente di scrittura che mi aiuta a redigere nuovi post sul blog utilizzando i miei contenuti esistenti come base di conoscenza.

NOTA: Questo fa parte dei miei esperimenti con l'AI (elaborazione assistita) + il mio editing.

  • Stessa voce, stesso pragmatismo, solo dita piu' veloci.
  • Pensate a come le pratiche legali moderne utilizzano LLMs addestrati sulla giurisprudenza per redigere briefs, mozioni e contratti.
  • Non partono da zero - i riferimenti di sistema precedenti rilevanti, suggerisce il linguaggio basato su documenti passati di successo, e mantiene la coerenza con modelli stabiliti.
  • E' esattamente quello che stiamo costruendo qui, ma per i contenuti del blog.
  • L'obiettivo è quello di creare un assistente di scrittura AI-powered che:

Aiuta la stesura di nuovi post sul blog nel mio stile stabilitoSuggerisce contenuti rilevanti dagli articoli precedenti al riferimentoTrova post simili per mantenere la coerenza

Auto-genera i collegamenti interni ai relativi articoli

Agisce come "GitHub Copilot per il tuo blog"

  • Questa serie coprirà la costruzione di un edificio completoGenerazione aumentata di recupero (RAG)
  • **sistema in C# che gira su Windows.**Useremo gli ultimi approcci e quadri, e spieghero' ogni nuova tecnologia mentre la incontriamo.
  • **La mia configurazione hardware (e le mie specifiche minime)**La mia macchina di sviluppo:

GPU**: NVIDIA RTX A4000 (16GB VRAM)**CPU

: AMD Ryzen 9 9950X

  • RAM: 96GB DDR5
    • Questa e' la mia configurazione specifica, ma tu
    • non ho bisogno di questo hardware
  • **Da seguire.**Ecco le specifiche minime per i diversi componenti:
    • Accelerazione GPU (raccomandata, non richiesta)
  • Minimo: NVIDIA GPU con VRAM da 8GB (ad es. RTX 3060, GTX 1070 Ti)

Può eseguire modelli di parametri 7B con quantizzazione

  • Velocità di generazione dell'imbottitura dignitosaConfortevole
  • **: 12GB+ VRAM (ad esempio, RTX 3060 12GB, RTX 4060 Ti)**Esegui modelli più grandi o quantizzazioni di qualità superiore
  • La mia configurazione
    • : 16GB (A4000) - Può eseguire i modelli 13B comodamente
    • Alternativa solo per CPU
    • Minimo

: CPU quad-core moderna

  • Raccomandato: 8+ core (per una ragionevole generazione di incorporamenti)
    • Tutto funziona solo su CPU, solo più lentamente:
  • Generazione di integrazione: ~5-10x più lentoInferenza LLM: ~10-50x più lento
    • Ancora completamente utilizzabile per un assistente di scrittura!
  • Requisiti RAMMinimo

: 16GB RAM di sistema

  • Inferenza solo CPU per modelli 7BConfortevole
  • 32GBMeglio per modelli più grandi su CPU

La mia configurazione

: 96GB - Overkill, 32GB è abbondanza

  • StoccaggioSSD
  • : Consigliato per il caricamento del modelloSpazio
  • : ~20GB per modelli e database vettorialiChe dire delle NPU Intel/AMD?

**Le CPU moderne ora includono acceleratori AI dedicati:*Intel Core Ultra(Meteor Lake+) - Intel AI Boost (NPU)*AMD Ryzen AI

(7040/8040 serie) - XDNA NPU

  • ✅ Great for: On-device inference, battery efficiency (laptops)
  • ⚠️ Limited for our use: Immature .NET/ONNX Runtime support
  • ❌ Not ready for: This project's primary path

AMD Ryzen AI Max

  1. (Punto Strix) - fino a 50 TOPSImportante: le NPU sono solo per l'inferenza!
  2. Non si "costruiscono" o treno modelli su NPU - sono progettati peresegui
  3. **modelli pre-allenati in modo efficiente.**I modelli vengono addestrati su GPU cloud (o workstation), poi scaricati e distribuiti su NPU per l'inferenza.
  4. **Stato attuale per i modelli in esecuzione su NPU (come da scrittura):**Perché non le NPU per questa serie?
  5. ecosistema software: CUDA ha più di 15 anni di maturità, supporto NPU in .NET è nascente

Compatibilità del modello

  • : La maggior parte dei modelli GGUF target CUDA/CPU, modelli ottimizzati NPU sono rariDocumentazione: Risorse limitate per lo sviluppo di NPU in C#
  • Prestazioni
  • : Attualmente più lento delle GPU discrete per il nostro carico di lavoro
  • Supporto DirectML

: Ancora sperimentale per l'inferenza LLM

# 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);

**Puoi usare le NPU per l'inferenza?**Si', maRichiedeDirectMLprovider di esecuzione in ONNX RuntimeI modelli devono essere in formato ONNX (non GGUF)

Il supporto C# è sperimentaleAttualmente le prestazioni sono inferiori rispetto a CUDA

Come provare l'inferenza NPU (utenti avanzati):

Considerazioni future

  1. : Una voltaONNX Runtime
  2. eDirectML
  3. **maturare il loro supporto NPU (probabilmente 2024-2025), queste diventeranno alternative valide per l'inferenza!**In fondo alla riga
  4. **: Mostrerò il percorso accelerato dalla GPU, ma noterò tutte le alternative solo della CPU.**È possibile avviare solo la CPU e l'aggiornamento più tardi!
  5. Quello che stiamo costruendoIl sistema finale avrà diversi componenti:
  6. Condotto per l'ingestione di marcatori verso il basso- Elabora tutti i post del blog, li ritaglia in modo intelligente e genera inserzioni

Banca dati vettoriale

- Memorizza e permette la ricerca semantica di contenuti simili

Applicazione client Windows

    • Un assistente di scrittura del desktop UI con l'editor e il pannello di suggerimento
  • Integrazione LLM

    • Inferenza accelerata GPU locale per la generazione di contenuti
  • Generazione di citazioni e collegamenti

  • Auto-suggests link interni e riferimenti ai post correlati

  • Motore di coerenza di stile

    • Imparare modelli da post esistenti per mantenere voce e struttura
  • Pensatelo come "GitHub Copilot incontra Grammarly" ma addestrato specificamente sul contenuto e lo stile del tuo blog.

  • Perche' "Avvocato GPT"?

  • Gli studi legali moderni utilizzano LLMs formati in vaste biblioteche di giurisprudenza per aiutare la bozza di documenti legali.

Quando si scrive un movimento, il sistema:

Riferimenti ai precedenti pertinenti e alle argomentazioni di successo del passato

Suggerisce modelli linguistici che hanno funzionato prima

Mantiene la coerenza con le norme giuridiche in materia di scrittura

Sorgenti cites automaticamente

E' il nostro modello.

Quando inizio a scrivere "Aggiungi un'Entità Framework per..." il sistema dovrebbe:Trova i miei post precedenti relativi all'impronta ambientale, Suggerisci schemi strutturali che ho usato primaOffrire snippet di codice pertinenti dagli articoli precedenti

Generazione automatica dei link ai post correlati

Mantenere il mio stile di scrittura e profondità tecnicaA differenza dei generici assistenti di scrittura AI, il nostro sistema è basato su contenuti passati reali, in modo da non suggerire le cose in contrasto con quello che ho già scritto.Panoramica delle serieEcco cosa copriremo nelle prossime settimane:).

Parte 1 (Questo post): Introduzione e architettura

Stabiliremo cosa stiamo costruendo e perché, oltre a coprire le decisioni architettoniche.

Parte 2: Configurazione GPU & CUDA in C#

Impostazione di Windows per carichi di lavoro AI accelerati dalla GPU, installazioneCUDACity name (optional, probably does not need a translation), CUDNN, e testare che C# può effettivamente vedere e utilizzare la tua GPU.Parte 3: Comprensione delle basi di dati e dei vettoriImmergetevi profondamente in ciò che ingloba realmente sono, come abilitano la ricerca semantica, e scegliendo il giusto database vettoriale (poiler: probabilmente useremo

QdrantCity name (optional, probably does not need a translation)

oppurepgvector, Parte 4: Costruzione del gasdotto per l'ingestioneElaborazione di file markdown, strategie di chunking intelligenti (non è possibile dividere solo i paragrafi!), e generazione di inserzioni per tutti i nostri contenuti.

Parte 5: Il client di Windows

Scegliere il quadro giusto (

WPF

AvaloniaCity name (optional, probably does not need a translation)

, oppure

MAUICity name (optional, probably does not need a translation)

?), costruendo l'interfaccia utente, e rendendo in realtà piacevole da usare.

Parte 6: Integrazione LLM locale

  1. Eseguire i modelli localmente usandoONNX Runtime
  2. llama.cpplegami, o altri approcci.
  3. **Facendo pieno uso di quell'A4000!**Parte 7: Generazione dei contenuti e Prompt Engineering
  4. **Riunire tutto - ricerca semantica di contenuti rilevanti, gestione delle finestre di contesto, ingegneria rapida per la scrittura di assistenza, e la generazione di suggerimenti coerenti.**Parte 8: Caratteristiche avanzate e distribuzione della produzione
  5. **Auto-linking ai post correlati, controllo coerenza stile, suggerimenti codice snippet, e rendere il sistema effettivamente utile per la scrittura quotidiana.**Perche' RAG?

Prima di tuffarci nell'architettura, parliamo del perché RAG (Retrieval Augmented Generation) è l'approccio giusto qui.

Il problema della fine-tuning

Si potrebbe pensare: "Perché non solo fine-tune un LLM su tutti i post del blog?" Ci sono diversi problemi con questo:

  1. Costi e complessità
    • La messa a punto è costosa (sia nel calcolo che nello sforzo)
  2. Instabilità
    • Ogni nuovo post sul blog significa riqualificazione
  3. Scatola nera
  • Difficile capire che cosa il modello "imparato"

  • ✅ Always up-to-date (just re-index new posts as you write them)

  • ✅ Grounded in your actual writing (maintains consistency)

  • ✅ Traceable (know which past posts influenced suggestions)

  • ✅ Efficient (no expensive retraining for every new post)

  • ✅ Flexible (can swap out LLMs or adjust search strategies)

  • ✅ Privacy-preserving (everything runs locally)

Allucinazioni

  • Nessuna garanzia che il modello non si inventi le cose.
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

Nessuna citazione

  • Non si possono rintracciare facilmente le risposte alle fonti

  • Come RAG risolve questo

  • RAG combina il meglio di entrambi i mondi: la potenza degli LLM con la precisione della ricerca per creare una generazione di contenuti context-aware.

  • Il flusso è:

  • L'utente inizia a scrivere (ad esempio, "Costruire un'API REST con ASP.NET Core...")

  • Il sistema trova semanticamente simili articoli passati

Il sistema alimenta i pezzi rilevanti come contesto dell'LLMLLM genera suggerimenti/proseguimento basati su contenuti passati

Il sistema offre suggerimenti con riferimenti ai messaggi sorgente

Ciò significa:

Architettura di sistema

Lasciatemi scomporre i componenti chiave che costruiremo:

  • Condotto per l'ingestione di marcatori verso il basso

**Questa componente:**Leggi i file di markdown dalla directory del blog

: La strategia di "Chunking" ha un'importanza enorme.

Troppo piccolo e si perde il contesto.

**Troppo grande e si spreca la finestra contestuale di LLM.**Abbiamo bisogno di pezzi che siano semanticamente significativi - un pensiero o una sezione completa, non interruzioni arbitrarie dei paragrafi.

Scelta della tecnologia

: Probabilmente useremo entrambi:

frase-trasformatori

modelli (può funzionare tramite ONNX Runtime in C#)

  • ✅ Mature, stable, lots of resources
  • ✅ Native Windows performance
  • ❌ Windows-only
  • ❌ Looks dated unless you invest in UI libraries

Modelli di integrazione di OpenAI (tramite API)

  • ✅ Cross-platform (XAML-based)
  • ✅ Modern, actively developed
  • ✅ Similar to WPF
  • ❌ Smaller ecosystem

Modelli BGE

  • ✅ Cross-platform
  • ✅ Microsoft-backed
  • ❌ Still maturing
  • ❌ More mobile-focused

(open source all'avanguardia)**3.Banca dati vettoriale**Il database vettoriale memorizza embeddings e consente la ricerca veloce somiglianza.**Quando si sta scrivendo di "Docker comporre," trova il K più semanticamente simile contenuto passato - non solo corrisponde parole chiave, ma materiale concettualmente collegato.**Scelta della tecnologia

: Noi valuteremo:

QdrantCity name (optional, probably does not need a translation)

    • Moderno, scritto in Rust, eccellente cliente C#, Docker-friendly
  • pgvector
    • Estensione per PostgreSQL (stiamo già usando Postgres!)
  • WeaviateCity name (optional, probably does not need a translation)

- Un'altra opzione solida con un buon supporto .NET:

ChromaCity name (optional, probably does not need a translation)

    • Popolare nella terra di Python, meno in C#
  • Mi sto appoggiando a Qdrant per la sua semplicità e prestazioni, o pgvector per mantenere tutto in Postgres.
  • Client di Windows

Abbiamo bisogno di un'interfaccia utente per scrivere con l'assistenza dell'AI.Pensa a un editor a pannello diviso con suggerimenti.

  • Opzioni:WPF (Windows Presentation Foundation))
  • AvaloniaCity name (optional, probably does not need a translation)
  • MAUI (UI app multipiattaforma)
  • Dato che siamo concentrati su Windows e voglio qualcosa di stabile, mi sto appoggiando verso

WPF con

  • Moderna interfaccia utente WPF
  • oppure
  • AvaloniaCity name (optional, probably does not need a translation)

per quel potenziale multipiattaforma.**5.**Integrazione LLM locale

Qui è dove brilla la GPU A4000.

Vogliamo eseguire l'LLM localmente per:

  • Privacy (nessun dato inviato alle API)
  • Velocità (l'inferenza locale è veloce)
  • Costo (nessun costo API)
  • Controllo (scegliamo il modello)

Opzioni tecnologiche

  • ONNX Runtime
  • Converti i modelli in formato ONNX
  • Eccellente accelerazione GPU
  • Supporto nativo C#

Downside: Non tutti i modelli convertono bene

llama.cpp

  • legature
  • Libreria C++ con attacchi C# (
  • LLamaSharp
  • Supporta CUDA
  • Ampio supporto per modelli (Llama, Mistral, ecc.)

Sviluppo molto attivo

TorchSharp

Legame PyTorch per .NET

  1. La maggior parte della flessibilitàCurva di apprendimento steeper
  2. Mi sto dirigendo versoLLamaSharp
  3. **per la sua maturità e facilità d'uso con modelli popolari.**6.
  4. Context Window Management & Prompt EngineeringI LLM hanno finestre di contesto limitate (ad esempio, 4K, 8K, 32K token).
  5. **Dobbiamo:**Recuperare il contenuto passato più rilevante (top K dalla ricerca vettoriale)

Adattali alla finestra contestuale con la bozza corrente

Strutturare il prompt per l'assistenza scritta

Lascia spazio ai suggerimenti generati

  • **E' piu' complicato di quanto sembri.**Esploreremo strategie come:
  • Selezione dinamica K in base a ciò che stai scrivendoRi-ranking pezzi recuperati per rilevanza

Comprimere il contesto in modo intelligente

Frammenti di codice usati

- La maggior parte degli esempi di RAG sono in Python.

- Ottimizzato per l'assistenza di scrittura del blog, generazione di contenuti non generica

(ultima al momento della scrittura)

LLamaSharp

  • Inferenza LLM

Microsoft.ML

  • - Potenzialmente per alcuni compitiTrasformatori di sentenza tramite ONNX
  • - AbbinamentiBanca dati vettoriale
  • **QdrantCity name (optional, probably does not need a translation)**oppure
  • pgvector- Da determinare

Quadro UI

  • WPFcon
  • WPF modernooppure
  • AvaloniaCity name (optional, probably does not need a translation)- interfaccia utente desktop moderna

Strumenti di supporto

  • MarkdigCity name (optional, probably does not need a translation)- L'ho gia' usato per l'analisi di markdown.
  • DockerCity name (optional, probably does not need a translation)- Per l'esecuzione di Qdrant o altri servizi
  • Centrale del quadro dell'entità- Se usiamo pgvector
  • Stack GPUCUDACity name (optional, probably does not need a translation)

12.x

  • **(ultima al momento della scrittura)**CUDNN
  • - Primitivi di apprendimento profondoConsiderazioni sulle prestazioni
  • **Diverse configurazioni hardware avranno diverse funzionalità:**Con VRAM da 8GB (minimo)
  • Dimensione del modello: Modelli di parametri 7B con quantizzazione Q4

Elaborazione di lotti

: Incorporazioni di processo in lotti più piccoli

  1. Gestione della memoria
  2. : Attento monitoraggio VRAM richiesto
  3. Funziona bene per
  4. : Assistente di scrittura, generazione di integrazione
  5. Con VRAM da 12GB+ (confortevole)
  6. Dimensione del modello

: 7B con quantizzazione di qualità superiore (Q5/Q6)

Elaborazione di lotti

: Botti più grandi per un flusso più veloce**Può anche essere eseguito**: Alcuni modelli 13B con quantizzazione aggressiva

  • Con VRAM da 16GB+ (la mia configurazione)
  • Dimensione del modello
  • : Modelli di parametri 7B-13B comodamente
  • Elaborazione di lotti
  • : Blocchi completi, vincoli minimi

Inferenza rapida

: Tempi di risposta di un secondo

Headroom

  • : Può sperimentare con diversi modelliSolo CPU (Fallback)
  • Tutto funziona., solo più lento
  • Incorporazioni: 5-10x più lento della GPU
  • Inferenza LLM: 10-50x più lento della GPU
  • Ancora utilizzabile: Per un assistente di scrittura con pazienza!

Approccio allo sviluppo

Lo costruiremo in modo incrementale:

Iniziare con i componenti più semplici (lettura dei marcatori, chunking)

Aggiungi generazione di embedding (potrebbe iniziare con API-based prima di andare locale)

Ottieni il funzionamento della ricerca vettoriale

Costruisci UI di base

Integrare LLM

Scrivere un semplice programma C# per verificare l'accesso alla GPU

Esecuzione di un test di inferenza di base con ONNX Runtime

Documentazione tecnica- Mantenere lo stile coerente su grandi set doc!

logo

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