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

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

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

<img src="https://media1.tenor.com/m/_rQc7PIEqwQAAAAd/cat-hello-cat-peek.gif" height="300px" />
## 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 stabilito[Suggerisce contenuti rilevanti dagli articoli precedenti al riferimento](https://www.anthropic.com/index/contextual-retrieval)Trova 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 completo**Generazione 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 dignitosa**Confortevole
- **: 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ù lento**Inferenza LLM: ~10-50x più lento
  - Ancora completamente utilizzabile per un assistente di scrittura!
- **Requisiti RAM**Minimo

### : 16GB RAM di sistema

- **Inferenza solo CPU per modelli 7B**Confortevole
- **32GB**Meglio per modelli più grandi su CPU

### La mia configurazione

: 96GB - Overkill, 32GB è abbondanza

- **Stoccaggio**SSD
- **: Consigliato per il caricamento del modello**Spazio
- **: ~20GB per modelli e database vettoriali**Che 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 TOPS**Importante: le NPU sono solo per l'inferenza!
2. **Non si "costruiscono" o treno modelli su NPU - sono progettati per**esegui
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 rari[Documentazione](https://github.com/microsoft/DirectML): 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**

```bash
# 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', ma[Richiede](https://onnxruntime.ai/)DirectML[provider di esecuzione in ONNX Runtime](https://github.com/microsoft/DirectML)I modelli devono essere in formato ONNX (non GGUF)

**Il supporto C# è sperimentale**Attualmente le prestazioni sono inferiori rispetto a CUDA

[TOC]

## Come provare l'inferenza NPU (utenti avanzati):

Considerazioni future

1. **: Una volta**ONNX Runtime
2. **e**DirectML
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 costruendo**Il 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.](/blog/building-a-lawyer-gpt-for-your-blog-part2)

Quando inizio a scrivere "Aggiungi un'Entità Framework per..." il sistema dovrebbe:[Trova i miei post precedenti relativi all'impronta ambientale](https://developer.nvidia.com/cuda-toolkit), [Suggerisci schemi strutturali che ho usato prima](https://developer.nvidia.com/cudnn)Offrire snippet di codice pertinenti dagli articoli precedenti

### [Generazione automatica dei link ai post correlati](/blog/building-a-lawyer-gpt-for-your-blog-part3)

Mantenere il mio stile di scrittura e profondità tecnica[A 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.](https://qdrant.tech/)Panoramica delle serie[Ecco cosa copriremo nelle prossime settimane:](https://github.com/pgvector/pgvector)).

### [Parte 1 (Questo post): Introduzione e architettura](/blog/building-a-lawyer-gpt-for-your-blog-part4)

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

### [Parte 2: Configurazione GPU & CUDA in C#](/blog/building-a-lawyer-gpt-for-your-blog-part5)

Impostazione di Windows per carichi di lavoro AI accelerati dalla GPU, installazione[CUDACity name (optional, probably does not need a translation)](https://docs.microsoft.com/en-us/dotnet/desktop/wpf/), [CUDNN](https://avaloniaui.net/), e testare che C# può effettivamente vedere e utilizzare la tua GPU.[Parte 3: Comprensione delle basi di dati e dei vettori](https://dotnet.microsoft.com/en-us/apps/maui)Immergetevi 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)](/blog/building-a-lawyer-gpt-for-your-blog-part6)

oppure[pgvector](https://onnxruntime.ai/), [Parte 4: Costruzione del gasdotto per l'ingestione](https://github.com/ggerganov/llama.cpp)Elaborazione 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](/blog/building-a-lawyer-gpt-for-your-blog-part7)

Scegliere il quadro giusto (

### [WPF](/blog/building-a-lawyer-gpt-for-your-blog-part8)

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 usando**ONNX Runtime
2. **llama.cpp**legami, 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à
2. - La messa a punto è costosa (sia nel calcolo che nello sforzo)
3. Instabilità
4. - Ogni nuovo post sul blog significa riqualificazione
5. 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.

```mermaid
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'LLM**LLM 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:

- 1.
- Condotto per l'ingestione di marcatori verso il basso

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

- [Estratti metadati (titolo, categorie, data, numero di parole)](https://www.sbert.net/)Intelligentemente ritaglia il contenuto (preservando blocchi di codice per il riutilizzo)
- Identifica i modelli strutturali (come organizzo i posti)
- [Tracce informazioni di origine per la generazione di citazioni](https://huggingface.co/BAAI/bge-base-en-v1.5)Sfida chiave

### : 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.

- **[2.](https://qdrant.tech/)**Modello di inserimento
- **[Le incastonate sono la magia che fa funzionare la ricerca semantica.](https://github.com/pgvector/pgvector)**Un modello incorporante prende il testo e lo converte in un vettore ad alta dimensione (raggio di numeri) che cattura il significato semantico.
- **[Concetti simili finiscono per "chiudere" nello spazio vettoriale, anche se usano parole diverse.](https://weaviate.io/)**Per esempio:
- **["migrazione della base dati" e "aggiornamento dello schema DB" avrebbero inserzioni simili](https://www.trychroma.com/)**"gatto" e "kitten" sarebbero più vicini di "gatto" e "database"

Scelta della tecnologia

### : Probabilmente useremo entrambi:

frase-trasformatori

**[modelli (può funzionare tramite ONNX Runtime in C#)](https://docs.microsoft.com/en-us/dotnet/desktop/wpf/)**

- ✅ 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)](https://avaloniaui.net/)**

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

**[Modelli BGE](https://dotnet.microsoft.com/en-us/apps/maui)**

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

(open source all'avanguardia)**3.[Banca dati vettoriale](https://github.com/Kinnara/ModernWpf)**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)](https://onnxruntime.ai/)**

- - 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.
- 4.
- Client di Windows

**[Abbiamo bisogno di un'interfaccia utente per scrivere con l'assistenza dell'AI.](https://github.com/ggerganov/llama.cpp)Pensa a un editor a pannello diviso con suggerimenti.**

- Opzioni:[WPF (Windows Presentation Foundation)](https://github.com/SciSharp/LLamaSharp))
- 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](https://github.com/dotnet/TorchSharp)**

- 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 verso**LLamaSharp
3. **per la sua maturità e facilità d'uso con modelli popolari.**6.
4. **Context Window Management & Prompt Engineering**I 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 scrivendo**Ri-ranking pezzi recuperati per rilevanza

### Comprimere il contesto in modo intelligente

- **[Suggerimento multi-shot con esempi da post passati](https://onnxruntime.ai/)**7.**[Generazione di collegamenti e citazioni](https://github.com/SciSharp/LLamaSharp)**Ogni pezzo ha bisogno di metadati:
- **[File sorgente/post](https://dotnet.microsoft.com/en-us/apps/machinelearning-ai/ml-dotnet)**Posizione nel documento originale
- **Data di pubblicazione**Categorie

### Frammenti di codice usati

- **[Quando l'LLM genera suggerimenti, creiamo automaticamente collegamenti markdown ai messaggi sorgente e identifichiamo i modelli di codice riutilizzabili.](https://qdrant.tech/)**Cosa lo rende diverso?**[Ci sono un sacco di tutorial RAG là fuori, ma questa serie sarà diversa:](https://github.com/pgvector/pgvector)**C# Primo

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

- **Stiamo andando pieno .NET**& GPU di Windows**- Levaging NVIDIA CUDA su Windows, non Linux/WSL**Produzione pronta**[- Non solo una prova del concetto, ma un vero e proprio codice utilizzabile.](https://avaloniaui.net/)**Domain-Specific

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

- **[Spiegazioni approfondite](https://github.com/xoofx/markdig)**- Spiegheremo il "perché" dietro le decisioni.
- **[Tecnologie che useremo](https://www.docker.com/)**Ecco la pila tecnologica che sto progettando:
- **[Quadro centrale](https://docs.microsoft.com/en-us/ef/core/)**.NET 9

### (ultima al momento della scrittura)

- **[C# 13](https://developer.nvidia.com/cuda-toolkit)- Caratteristiche linguistiche moderne**Librerie AI/ML
- **[ONNX Runtime](https://developer.nvidia.com/cudnn)**oppure

## LLamaSharp

- Inferenza LLM

### Microsoft.ML

- **- Potenzialmente per alcuni compiti**Trasformatori di sentenza tramite ONNX
- **- Abbinamenti**Banca dati vettoriale
- **QdrantCity name (optional, probably does not need a translation)**oppure
- **pgvector**- Da determinare

### Quadro UI

- **WPF**con
- **WPF moderno**oppure
- **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 GPU**CUDACity name (optional, probably does not need a translation)

### 12.x

- **(ultima al momento della scrittura)**CUDNN
- **- Primitivi di apprendimento profondo**Considerazioni 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](/blog/building-a-lawyer-gpt-for-your-blog-part2)**: 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 modelli**Solo 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

- **Polacco e ottimizzare**Ogni parte sarà disponibile e testabile da sola.
- [Niente incubi di integrazione.](/blog/building-a-lawyer-gpt-for-your-blog-part2)
- [Cosa c'e' dopo?](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Dentro](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Parte 2: Configurazione GPU & CUDA in C#](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [, ci metteremo in contatto con la configurazione della GPU:](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [Installazione di CUDA e cuDNN su Windows](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Creazione dell'ambiente di sviluppo](/blog/building-a-lawyer-gpt-for-your-blog-part8)

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

Esecuzione di un test di inferenza di base con ONNX Runtime

- [Benchmarking il nostro A4000 per capire cosa possiamo fare](https://onnxruntime.ai/)
- [Questo potrebbe sembrare fondamentale, ma ottenere lo stack GPU a destra è fondamentale.](https://github.com/SciSharp/LLamaSharp)
- [Ho sprecato ore a debug di problemi che sono arrivati alla versione non corretta o alle DLL mancanti.](https://qdrant.tech/documentation/)
- [Perché questo è importante](https://www.sbert.net/)
- [Oltre ad essere solo un progetto cool, questo approccio ha applicazioni reali:](https://www.anthropic.com/index/contextual-retrieval)

Documentazione tecnica[- Mantenere lo stile coerente su grandi set doc](/blog/building-a-lawyer-gpt-for-your-blog-part2)!