# Bâtir un « avocat GPT » pour votre blog - Partie 1: Introduction et architecture

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

> AVERTISSEMENT: CES PROJETS DE POSTES QUI 'ESCAPÉ'.

Il est probable qu'une grande partie de ce qui est ci-dessous ne fonctionnera pas; je les génère comme comment faire pour MOI, puis faire toutes les étapes et obtenir le travail de l'application d'échantillon ... Vous avez été sournois et les a vus! ils seront probablement prêts à la mi-décembre.

<img src="https://media1.tenor.com/m/_rQc7PIEqwQAAAAd/cat-hello-cat-peek.gif" height="300px" />
## Présentation

Serrez-vous parce que ça va être une longue série !

> Si vous avez suivi ce blog, vous saurez que je suis un peu obsédé par la recherche de façons intéressantes d'utiliser les LLM et l'IA dans des applications pratiques.

Eh bien, j'ai un nouveau projet qui combine mon amour pour les blogs, C#, et AI: construire un assistant d'écriture qui m'aide à rédiger de nouveaux billets de blog en utilisant mon contenu existant comme base de connaissances.

REMARQUE: Ceci fait partie de mes expériences avec l'IA (couture assistée) + mon propre montage.

- Même voix, même pragmatisme, juste des doigts plus rapides.
- Pensez à la façon dont les pratiques juridiques modernes utilisent les LLM formés à la jurisprudence pour rédiger des mémoires, des motions et des contrats.
- Ils ne commencent pas à partir de zéro - le système fait référence aux précédents pertinents, suggère un langage basé sur des documents passés réussis, et maintient la cohérence avec les modèles établis.
- C'est exactement ce que nous construisons ici, mais pour le contenu du blog.
- L'objectif est de créer un assistant d'écriture à puissance d'IA qui :

Aide à rédiger de nouveaux billets de blog dans mon style établi[Suggère le contenu pertinent des articles antérieurs à la référence](https://www.anthropic.com/index/contextual-retrieval)Trouver des postes similaires pour maintenir la cohérence

## Génére automatiquement des liens internes vers des articles connexes

**Agit comme "GitHub Copilot pour votre blog"**

- **Cette série couvrira la construction d'un**Retrieval Augmented Generation (RAG)
- **système en C# qui fonctionne sous Windows.**Nous utiliserons les approches et les cadres les plus récents, et je vais expliquer chaque nouvelle technologie que nous rencontrons.
- **Ma configuration matérielle (et les spécifications minimales)**Ma machine de développement :

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

### : AMD Ryzen 9 9950X

- **RAM**: 96 Go DDR5
  - C'est mon installation spécifique, mais toi
  - Je n'ai pas besoin de ce matériel.
- **à suivre.**Voici les caractéristiques minimales pour différents composants:
  - Accélération du GPU (Recommandé, non requis)
- **Minimum**: GPU NVIDIA avec VRAM de 8 Go (par exemple RTX 3060, GTX 1070 Ti)

### Peut exécuter des modèles de paramètres 7B avec quantification

- **Vitesse de génération décentée d'intégration**Confortable
- **: VRAM de 12 Go+ (par exemple RTX 3060 12 Go, RTX 4060 Ti)**Exécuter des modèles plus grands ou des quantifications de qualité supérieure
- Mon installation
  - : 16 Go (A4000) - Peut rouler confortablement les modèles 13B
  - CPU-seulement alternative
  - Minimum

### : CPU moderne quad-core

- **Recommandé**: 8+ cœurs (pour une génération d'intégration raisonnable)
  - Tout fonctionne sur CPU-seulement, juste plus lentement:
- **Génération d'assemblage: ~5-10x plus lentement**Inférence LLM: ~10-50x plus lentement
  - Toujours totalement utilisable pour un assistant d'écriture !
- **Exigences en matière de RAM**Minimum

### : Système RAM de 16 Go

- **Inférence CPU uniquement pour les modèles 7B**Confortable
- **: 32 Go**Mieux pour les modèles plus grands sur CPU

### Mon installation

: 96 Go - Surkill, 32 Go c'est beaucoup

- **Stockage**SSD
- **: Recommandé pour le chargement du modèle**Espace
- **: ~20 Go pour les modèles et la base de données vectoriels**Qu'en est-il des NPU Intel/AMD?

**Les processeurs modernes incluent désormais des accélérateurs d'IA dédiés:**Intel Core Ultra*(Meteor Lake+) - Intel AI Boost (NPU)*AMD Ryzen AI

**(série 7040/8040) - NPU XDNA**

- ✅ 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. **(Strix Point) - Jusqu'à 50 TOPS**Important : les NPU sont pour l'inférence seulement !
2. **Vous ne "construisez" pas ou les modèles de train sur les NPU - ils sont conçus pour**lancer
3. **modèles pré-formés efficacement.**Les modèles sont formés sur les GPU en nuage (ou les postes de travail), puis téléchargés et déployés dans les NPU pour inférence.
4. **État actuel des modèles en cours d'exécution sur les NPU (au moment de l'écriture):**Pourquoi pas des NPU pour cette série ?
5. **Écosystème logiciel**: CUDA a plus de 15 ans d'échéance, le soutien NPU dans .NET est naissant

**Compatibilité du modèle**

- : La plupart des modèles GGUF ciblent CUDA/CPU, les modèles optimisés NPU sont rares[Documentation](https://github.com/microsoft/DirectML): Ressources limitées pour le développement de l'UPN en C#
- Résultats
- : Actuellement plus lent que les GPU discrets pour notre charge de travail
- Appui direct au ML

**: Toujours expérimental pour l'inférence 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);
```

**Pouvez-vous utiliser des NPU à des fins d'inférence?**Oui, mais :[Nécessite](https://onnxruntime.ai/)DirectML[fournisseur d'exécution dans ONNX Runtime](https://github.com/microsoft/DirectML)Les modèles doivent être au format ONNX (pas GGUF)

**Le support C# est expérimental**La performance est actuellement sous-estimée par rapport à CUDA

[TOC]

## Comment essayer l'inférence NPU (utilisateurs avancés) :

Examen futur

1. **: Une fois**ONNX Durée d'exécution
2. **et**DirectML
3. **mature leur soutien NPU (probablement 2024-2025), ceux-ci deviendront des alternatives viables pour l'inférence!**Ligne de fond
4. **: Je vais montrer le chemin accéléré du GPU, mais je noterai les alternatives du CPU seulement dans l'ensemble.**Vous pouvez démarrer CPU-seulement et mettre à niveau plus tard!
5. **Ce que nous construisons**Le système final comportera plusieurs composantes:
6. **Pipeline d'ingestion de balisage**- Traite tous les messages de blog, les chunks intelligemment, et génère des intégrations

Base de données vectorielles

## - Stores embarque et permet une recherche sémantique pour des contenus similaires

Application client Windows

- - Une interface d'écriture de bureau avec éditeur et panneau de suggestion
- Intégration LLM
- - Inférence locale accélérée GPU pour la génération de contenu
- Citation et génération de liens

- Auto-suggère des liens internes et des références à des messages connexes

- Moteur de cohérence de style
- - Apprend les modèles des postes existants pour maintenir la voix et la structure
- Pensez-y comme "GitHub Copilot rencontre Grammarly" mais formé spécifiquement sur le contenu et le style de votre blog.
- Pourquoi "avocat GPT" ?
- Les cabinets d'avocats modernes utilisent des LLM formés à de vastes bibliothèques de jurisprudence pour aider à rédiger des documents juridiques.

Lors de l'écriture d'une motion, le système :

## Références de précédents pertinents et d'arguments positifs antérieurs

Suggère des modèles de langue qui ont déjà fonctionné

### Maintient la cohérence avec les normes juridiques de rédaction

Cites sources automatiquement

### [C'est notre modèle.](/blog/building-a-lawyer-gpt-for-your-blog-part2)

Lorsque je commence à écrire « Ajouter un cadre d'entité pour... », le système devrait :[Trouver mes précédents postes liés à l'EF](https://developer.nvidia.com/cuda-toolkit), [Suggère des modèles structuraux que j'ai déjà utilisés](https://developer.nvidia.com/cudnn)Offrez des extraits de code pertinents des articles précédents

### [Générer automatiquement des liens vers des messages connexes](/blog/building-a-lawyer-gpt-for-your-blog-part3)

Maintenez mon style d'écriture et ma profondeur technique[Contrairement aux assistants génériques d'écriture d'IA, notre système est basé sur du contenu passé réel, de sorte qu'il ne suggérera pas des choses incompatibles avec ce que j'ai déjà écrit.](https://qdrant.tech/)Aperçu de la série[Voici ce qu'on va couvrir au cours des prochaines semaines :](https://github.com/pgvector/pgvector)).

### [Partie 1 (Ce billet): Introduction et Architecture](/blog/building-a-lawyer-gpt-for-your-blog-part4)

Nous établirons ce que nous construisons et pourquoi, en plus de couvrir les décisions architecturales.

### [Partie 2: Configuration GPU & CUDA en C#](/blog/building-a-lawyer-gpt-for-your-blog-part5)

Mise en place de Windows pour les charges de travail d'IA accélérées par GPU, installation[CUDA](https://docs.microsoft.com/en-us/dotnet/desktop/wpf/), [CUDNN](https://avaloniaui.net/), et de tester que C# peut réellement voir et utiliser votre GPU.[Partie 3: Compréhension des intégrations et des bases de données vectorielles](https://dotnet.microsoft.com/en-us/apps/maui)Plongez profondément dans ce que sont réellement les éléments d'intégration, comment ils permettent la recherche sémantique, et choisissez la bonne base de données vectorielle (spoiler: nous allons probablement utiliser

### [Qdurant](/blog/building-a-lawyer-gpt-for-your-blog-part6)

ou[Pgvector](https://onnxruntime.ai/), [Partie 4: Construction du pipeline d'ingestion](https://github.com/ggerganov/llama.cpp)Traitement des fichiers de balisage, stratégies de chunking intelligentes (vous ne pouvez pas simplement diviser sur les paragraphes!), et générer des intégrations pour tout notre contenu.

### [Partie 5: Le client Windows](/blog/building-a-lawyer-gpt-for-your-blog-part7)

Choisir le cadre approprié (

### [Groupe de travail de la sécurité et de la sécurité au travail](/blog/building-a-lawyer-gpt-for-your-blog-part8)

Avalonie

## , ou

MAUIE

### ?), en construisant l'assurance-chômage et en rendant l'utilisation plus agréable.

Partie 6: Intégration locale des LLM

1. **Modèles en cours d'exécution à l'échelle locale**ONNX Durée d'exécution
2. **Lama.cpp**des liens, ou d'autres approches.
3. **En utilisant pleinement ce A4000 !**Partie 7: Génération de contenu et génie rapide
4. **Rassembler tout cela - recherche sémantique de contenu pertinent, gestion des fenêtres contextuelles, ingénierie rapide pour l'aide à l'écriture, et générer des suggestions cohérentes.**Partie 8: Caractéristiques avancées et déploiement de la production
5. **Lien automatique vers des messages connexes, vérification de la cohérence du style, suggestions d'extrait de code, et rendre le système réellement utile pour l'écriture quotidienne.**Pourquoi RAG ?

### Avant de plonger dans l'architecture, parlons de la raison pour laquelle RAG (Retrieval Augmented Generation) est la bonne approche ici.

Le problème avec le tuning fin

Vous pourriez penser: "Pourquoi ne pas simplement peaufiner un LLM sur tous les billets de blog?" Il ya plusieurs problèmes avec cela:

1. Coût et complexité
2. - Le réglage fin est coûteux (à la fois dans le calcul et l'effort)
3. Staleness
4. - Chaque nouveau billet de blog signifie recyclage
5. Boîte noire

- Difficile de comprendre ce que le modèle "apprenait"

- ✅ 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)

## hallucination

- Pas de garantie que le modèle n'inventera rien.

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

### Pas de citations

- Il n'est pas facile de retracer les réponses aux sources.

- Comment le RAG s'y prend-il?
- RAG combine le meilleur des deux mondes : la puissance des LLM avec la précision de la recherche pour créer une génération de contenu contextuelle.
- Le débit est:
- L'utilisateur commence à écrire (par exemple, "Construire une API REST avec ASP.NET Core...")
- System trouve sémantiquement des articles antérieurs similaires

**Système alimente des morceaux pertinents en contexte pour le LLM**LLM génère des suggestions/continuations basées sur du contenu passé

### Système offre des suggestions avec des références aux messages sources

Cela signifie:

Architecture du système

Permettez-moi de décomposer les éléments clés que nous allons construire:

- 1. Le Conseil de l'Europe a adopté une résolution du Conseil de l'Europe sur la situation des droits de l'homme dans le monde.
- Pipeline d'ingestion de balisage

**Cette composante:**Lit les fichiers de balisage à partir du répertoire du blog

- [Extraire des métadonnées (titre, catégories, date, nombre de mots)](https://www.sbert.net/)Découpe intelligemment le contenu (préservation de blocs de code pour réutilisation)
- Indique les schémas structurels (comment j'organise les postes)
- [Tracks source information pour la génération de citations](https://huggingface.co/BAAI/bge-base-en-v1.5)Défi clé

### : La stratégie de coupe est très importante.

Trop petit et tu perds le contexte.

**Trop grand et vous gaspillez la fenêtre contextuelle du LLM.**Nous avons besoin de morceaux qui ont un sens sémantique - une pensée ou une section complète, et non des ruptures de paragraphes arbitraires.

- **[2. Le Président. — L'ordre du jour appelle le rapport (doc.](https://qdrant.tech/)**Modèle d'intégration
- **[Les inscriptions sont la magie qui fait travailler la recherche sémantique.](https://github.com/pgvector/pgvector)**Un modèle d'intégration prend du texte et le convertit en un vecteur haute-dimensionnel (array of numbers) qui capture la signification sémantique.
- **[Des concepts similaires finissent par "fermer" dans l'espace vectoriel, même s'ils utilisent des mots différents.](https://weaviate.io/)**Par exemple:
- **["migration de base de données" et "mise à jour du schéma DB" auraient des intégrations similaires](https://www.trychroma.com/)**"cat" et "kitten" seraient plus proches que "cat" et "base de données"

Choix technologique

### : Nous utiliserons probablement l'un ou l'autre :

transformateurs de phrases

**[modèles (peut fonctionner via ONNX Runtime en 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

**[Modèles d'intégration d'OpenAI (via API)](https://avaloniaui.net/)**

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

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

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

(source ouverte à la fine pointe de la technologie)**3. Les droits de l'homme sont garantis par le Pacte international relatif aux droits économiques, sociaux et culturels.[Base de données vectorielles](https://github.com/Kinnara/ModernWpf)**La base de données vectorielle stocke l'intégration et permet une recherche rapide de similarité.**Lorsque vous écrivez sur "Docker composer", il trouve le K le plus sémantiquement similaire contenu passé - pas seulement des correspondances de mots clés, mais du matériel lié conceptuellement.**Choix technologique

### : Nous évaluerons :

Qdurant

- - Moderne, écrit en Rust, excellent client C#, Docker-friendly
- Pgvector
- - Extension pour PostgreSQL (nous utilisons déjà Postgres!)
- Façonné

**- Une autre option solide avec un bon support .NET**:

**[Chroma](https://onnxruntime.ai/)**

- - Populaire en terre de Python, moins en C#
- Je me penche vers Qdurant pour sa simplicité et sa performance, ou pgvector pour garder tout dans Postgres.
- 4. Le Président. — L'ordre du jour appelle le rapport (doc.
- Client Windows

**[Nous avons besoin d'une bonne UI pour écrire avec l'aide de l'IA.](https://github.com/ggerganov/llama.cpp)Pensez à l'éditeur de panneaux séparés avec des suggestions.**

- Options:[WPF (Fondation de présentation Windows)](https://github.com/SciSharp/LLamaSharp))
- Avalonie
- MAUI (interface utilisateur multiplateforme)
- Puisque nous sommes centrés sur Windows et que je veux quelque chose de stable, je me penche vers

**[WPF avec](https://github.com/dotnet/TorchSharp)**

- UI moderne WPF
- ou
- Avalonie

pour ce potentiel multiplateforme.**5.**Intégration locale des LLM

### C'est là que brille l'A4000 GPU.

Nous voulons gérer le LLM localement pour:

- Confidentialité (aucune donnée envoyée aux API)
- Vitesse (l'inférence locale est rapide)
- Coût (pas de frais d'API)
- Contrôle (nous choisissons le modèle)

Options technologiques

- ONNX Durée d'exécution
- Convertir les modèles en format ONNX
- Excellente accélération du GPU
- Soutien natif C#

### A l'envers: Tous les modèles ne se convertissent pas bien

Lama.cpp

- liants
- Bibliothèque C++ avec fixations C# (
- LLamaSharp
- Soutient CUDA
- Support de modèle large (Llama, Mistral, etc.)

Développement très actif

## TorcheSharp

Fixations PyTorch pour .NET

1. **La plus grande flexibilité**Courbe d'apprentissage Steeper
2. **Je me penche vers**LLamaSharp
3. **pour sa maturité et sa facilité d'utilisation avec des modèles populaires.**6.
4. **Contexte Gestion de fenêtres & Ingénierie rapide**Les LLM ont des fenêtres de contexte limitées (p. ex., 4K, 8K, 32K jetons).
5. **Nous devons :**Récupérer le contenu passé le plus pertinent (top K de la recherche vectorielle)

## Fixez-les dans la fenêtre contextuelle avec le projet actuel

Structurer la demande d'aide à l'écriture

### Laisser place aux suggestions générées

- **C'est plus compliqué que ça en a l'air.**Nous explorerons des stratégies comme :
- **Sélection dynamique K basée sur ce que vous écrivez actuellement**Reclasser les morceaux récupérés par pertinence

### Compresser le contexte intelligemment

- **[Invitation multi-shot avec des exemples de posts passés](https://onnxruntime.ai/)**7.**[Génération de liens et de citations](https://github.com/SciSharp/LLamaSharp)**Chaque morceau a besoin de métadonnées :
- **[Fichier source/poste](https://dotnet.microsoft.com/en-us/apps/machinelearning-ai/ml-dotnet)**Position dans le document original
- **Date de publication**Catégories

### Extraits de code utilisés

- **[Lorsque le LLM génère des suggestions, nous créons automatiquement des liens de balisage vers les messages sources et identifions les modèles de code réutilisables.](https://qdrant.tech/)**Qu'est - ce qui rend cela différent?**[Il y a beaucoup de tutoriels RAG là-bas, mais cette série sera différente:](https://github.com/pgvector/pgvector)**C# D'abord

### - La plupart des exemples de RAG sont en Python.

- **Nous allons plein .NET**Windows & GPU**- Utilisation de NVIDIA CUDA sur Windows, pas Linux/WSL**Prête à la production**[- Pas seulement la preuve de concept, mais le vrai code utilisable](https://avaloniaui.net/)**Domaine spécifique

### - Optimisé pour l'aide à l'écriture de blog, pas la génération de contenu générique

- **[Explications profondes](https://github.com/xoofx/markdig)**- On expliquera le "pourquoi" derrière les décisions
- **[Technologies que nous utiliserons](https://www.docker.com/)**Voici la pile technologique que je prévois :
- **[Cadre de base](https://docs.microsoft.com/en-us/ef/core/)**.NET 9

### (dernière au moment de l'écriture)

- **[C# 13](https://developer.nvidia.com/cuda-toolkit)- Caractéristiques linguistiques modernes**Bibliothèques AI/ML
- **[ONNX Durée d'exécution](https://developer.nvidia.com/cudnn)**ou

## LLamaSharp

- Inférence LLM

### Microsoft.ML

- **- Potentiellement pour certaines tâches**Transformateurs de peine via ONNX
- **- Embeddings**Base de données vectorielles
- **Qdurant**ou
- **Pgvector**- À déterminer

### Cadre de l'assurance-chômage

- **Groupe de travail de la sécurité et de la sécurité au travail**avec
- **FPMT moderne**ou
- **Avalonie**- L'interface utilisateur de bureau moderne

### Outils d'appui

- **Marqueur**- Déjà utilisé pour l'analyse de balisage
- **Poivrons**- Pour l'exploitation de Qdrant ou d'autres services
- **Cadre de base pour les entités**- Si nous utilisons pgvector
- **Stack GPU**CUDA

### 12.x

- **(dernière au moment de l'écriture)**CUDNN
- **- L'apprentissage profond des primitifs**Considérations de performance
- **Différentes configurations matérielles auront des capacités différentes:**Avec VRAM de 8 Go (minimum)
- **Taille du modèle**: Modèles de paramètres 7B avec quantification Q4

## Traitement par lots

: Incrustations de processus dans des lots plus petits

1. Gestion de la mémoire
2. : Surveillance VRAM attentive requise
3. Fonctionne bien pour
4. : Assistant à l'écriture, génération d'intégration
5. Avec VRAM de 12 Go+ (Confortable)
6. Taille du modèle

: 7B avec une quantification de qualité supérieure (Q5/Q6)

## Traitement par lots

: Des lots plus grands pour un débit plus rapide**[Peut aussi fonctionner](/blog/building-a-lawyer-gpt-for-your-blog-part2)**: Quelques modèles 13B avec quantification agressive

- Avec 16 Go + VRAM (Ma configuration)
- Taille du modèle
- : Modèles de paramètres 7B-13B confortablement
- Traitement par lots
- : Lots complets, contraintes minimales

Inférence rapide

## : Temps de réponse de la sous-seconde

Salle de classe

- **: Peut expérimenter avec différents modèles**CPU-seulement (Fallback)
- **Tout fonctionne**, juste plus lentement
- **Assemblages**: 5-10x plus lentement que GPU
- **Inférence LLM**: 10-50x plus lentement que GPU
- **Toujours utilisable**: Pour un assistant d'écriture avec patience !

Approche de développement

## Nous allons construire cela progressivement:

Démarrer avec des composants les plus simples (balayage, décrochage)

Ajouter la génération d'intégration (pourrait commencer avec API-based avant d'aller local)

Obtenir le travail de recherche vectorielle

Construire l'interface utilisateur de base

## Intégrer les LLM

- **Polonais et optimiser**Chaque pièce sera déployable et testable toute seule.
- [Pas de cauchemars d'intégration.](/blog/building-a-lawyer-gpt-for-your-blog-part2)
- [Qu'est-ce qu'il y a ?](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Dans](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Partie 2: Configuration GPU & CUDA en C#](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [, nous allons obtenir des mains-sur avec la configuration GPU:](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [Installation de CUDA et cudNN sur Windows](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Mise en place de l'environnement de développement](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## Écrire un programme C# simple pour vérifier l'accès GPU

Effectuer un test d'inférence de base avec ONNX Runtime

- [Benchmarking notre A4000 pour comprendre ce que nous pouvons faire](https://onnxruntime.ai/)
- [Cela peut sembler fondamental, mais obtenir la pile GPU à droite est crucial.](https://github.com/SciSharp/LLamaSharp)
- [J'ai gaspillé des heures de débogage des problèmes qui sont descendus à des erreurs de version ou DLL manquantes.](https://qdrant.tech/documentation/)
- [Pourquoi cela importe-t-il?](https://www.sbert.net/)
- [Au-delà d'être un projet cool, cette approche a de vraies applications :](https://www.anthropic.com/index/contextual-retrieval)

Documentation technique[- Maintien d'un style cohérent sur les grands ensembles de documents](/blog/building-a-lawyer-gpt-for-your-blog-part2)!