# Construyendo un "Abogado GPT" para su Blog - Parte 1: Introducción y Arquitectura
2025-11-12T22:45
> ATENCIÓN: Estos son los proyectos de mensajes que se han "espaciado".
Es probable que gran parte de lo que está a continuación no funcione; Yo genera estos como cómo para MÍ y luego hacer todos los pasos y hacer que la aplicación de muestra funcione...¡Has sido astuto y los has visto!Probablemente estarán listos a mediados de diciembre.
## Introducción
¡Abróchate el cinturón porque esto va a ser una serie larga!
> Si has estado siguiendo junto con este blog, sabrás que estoy un poco obsesionado con encontrar maneras interesantes de usar LLMs e IA en aplicaciones prácticas.
Bueno, tengo un nuevo proyecto que combina mi amor por los blogs, C# y AI: construir un asistente de escritura que me ayude a redactar nuevos posts usando mi contenido existente como base de conocimiento.
NOTA: Esto es parte de mis experimentos con IA (redacción asistida) + mi propia edición.
- La misma voz, el mismo pragmatismo; sólo los dedos más rápidos.
- Piense en cómo las prácticas legales modernas utilizan los LLM entrenados en jurisprudencia para redactar informes, mociones y contratos.
- No comienzan de cero - el sistema hace referencia a precedentes relevantes, sugiere un lenguaje basado en documentos anteriores exitosos, y mantiene la coherencia con los patrones establecidos.
- Eso es exactamente lo que estamos construyendo aquí, pero para contenido de blog.
- El objetivo es crear un asistente de escritura con IA que:
Ayuda a redactar nuevas entradas de blog en mi estilo establecido[Sugiere contenido relevante de artículos anteriores a referencia](https://www.anthropic.com/index/contextual-retrieval)Encuentra publicaciones similares para mantener la consistencia
## Genera automáticamente enlaces internos a artículos relacionados
**Actúa como "GitHub Copilot para tu blog"**
- **Esta serie cubrirá la construcción de un completo**Generación aumentada de obtención (RAG)
- **sistema en C# que se ejecuta en Windows.**Usaremos los últimos enfoques y marcos, y explicaré cada nueva tecnología a medida que la encontremos.
- **Mi configuración de hardware (y especificaciones mínimas)**Mi máquina de desarrollo:
GPU**: NVIDIA RTX A4000 (16GB VRAM)**CPU
### : AMD Ryzen 9 9950X
- **RAM**: 96GB DDR5
- Esta es mi configuración específica, pero tú
- No necesito este hardware.
- **seguir adelante.**Estas son las especificaciones mínimas para diferentes componentes:
- Aceleración de la GPU (recomendada, no requerida)
- **Mínimo**: NVIDIA GPU con 8GB VRAM (por ejemplo, RTX 3060, GTX 1070 Ti)
### Puede ejecutar modelos de parámetros 7B con cuantificación
- **Velocidad de generación de incrustación decente**Cómodo
- **: 12GB+ VRAM (por ejemplo, RTX 3060 12GB, RTX 4060 Ti)**Ejecutar modelos más grandes o cuantificaciones de mayor calidad
- Mi configuración
- : 16GB (A4000) - Puede ejecutar modelos 13B cómodamente
- Alternativas solo para CPU
- Mínimo
### : CPU moderna de cuatro núcleos
- **Recomendado**: 8+ núcleos (para una generación de incrustación razonable)
- Todo funciona sólo en la CPU, sólo más lento:
- **Generación de empotrado: ~5-10x más lento**Inferencia LLM: ~10-50x más lento
- Todavía totalmente utilizable para un asistente de escritura!
- **Requisitos de RAM**Mínimo
### : RAM del sistema de 16 GB
- **Inferencia exclusiva de CPU para modelos 7B**Cómodo
- **: 32GB**Mejor para modelos más grandes en CPU
### Mi configuración
: 96GB - Overkill, 32GB es suficiente
- **Almacenamiento**SSD
- **: Recomendado para la carga de modelos**Espacio
- **: ~20GB para modelos y base de datos de vectores**¿Qué hay de las NPUs Intel/AMD?
**Las CPU modernas ahora incluyen aceleradores de IA dedicados:**Intel Core Ultra*(Meteor Lake+) - Intel AI Boost (NPU)*AMD Ryzen AI
**(serie 7040/8040) - 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) - Hasta 50 TOPS**Importante: ¡Las NPUs son sólo para inferencia!
2. **No se "construyen" o se entrenan modelos en NPUs - están diseñados para**ejecutar
3. **modelos pre-entrenados de manera eficiente.**Los modelos se entrenan en GPUs en la nube (o estaciones de trabajo), luego se descargan e implementan en NPUs para su inferencia.
4. **Estado actual de los modelos de ejecución en NPUs (a la fecha de redacción):**¿Por qué no NPUs para esta serie?
5. **Ecosistema de programas informáticos**: CUDA tiene más de 15 años de madurez, apoyo NPU en .NET es naciente
**Compatibilidad con los modelos**
- : La mayoría de los modelos GGUF se dirigen a CUDA/CPU, los modelos optimizados NPU son raros[Documentación](https://github.com/microsoft/DirectML): Recursos limitados para el desarrollo de la NPU en C#
- Desempeño
- : Actualmente más lento que las GPUs discretas para nuestra carga de trabajo
- Soporte DirectML
**: Todavía experimental para la inferencia de 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);
```
**¿Puedes usar NPUs para inferir?**Sí, pero:[Requerimientos](https://onnxruntime.ai/)DirectML[proveedor de ejecución en ONNX Runtime](https://github.com/microsoft/DirectML)Los modelos deben estar en formato ONNX (no GGUF)
**El soporte C# es experimental**En la actualidad, el rendimiento es insuficiente frente a CUDA
[TOC]
## Cómo probar la inferencia NPU (usuarios avanzados):
Examen futuro
1. **Una vez**ONNX Runtime
2. **y**DirectML
3. **madurar su apoyo NPU (probablemente 2024-2025), estas se convertirán en alternativas viables para la inferencia!**Conclusión
4. **: Mostraré la ruta acelerada por GPU, pero notaré alternativas solo para CPU en todo momento.**¡Puedes iniciar solo la CPU y actualizarla más tarde!
5. **Lo que estamos construyendo**El sistema final tendrá varios componentes:
6. **Gasoducto de Ingestión de Markdown**- Procesa todos los posts del blog, los divide inteligentemente, y genera incrustaciones
Base de datos vectorial
## - Almacena incrustaciones y permite la búsqueda semántica de contenidos similares
Aplicación Windows Client
- - Un asistente de escritura de escritorio IU con editor y panel de sugerencias
- Integración de LLM
- - Inferencia acelerada por la GPU local para la generación de contenido
- Generación de citas y enlaces
- Auto-sugiere enlaces internos y referencias a publicaciones relacionadas
- Motor de consistencia de estilo
- - Aprende patrones de los puestos existentes para mantener la voz y la estructura
- Piense en ello como "GitHub Copilot se reúne con Grammarly", pero entrenado específicamente en el contenido y el estilo de su blog.
- ¿Por qué "Abogado GPT"?
- Los bufetes de abogados modernos utilizan LLMs formados en vastas bibliotecas de jurisprudencia para ayudar a redactar documentos jurídicos.
Al escribir una moción, el sistema:
## Referencias precedentes pertinentes y argumentos que han tenido éxito en el pasado
Sugiere patrones de lenguaje que han funcionado antes
### Mantiene la coherencia con las normas jurídicas de redacción
Cites fuentes automáticamente
### [Ese es nuestro modelo.](/blog/building-a-lawyer-gpt-for-your-blog-part2)
Cuando empiezo a escribir "Adding Entity Framework for...", el sistema debería:[Encuentra mis posts anteriores relacionados con la FE](https://developer.nvidia.com/cuda-toolkit), [Sugerir patrones estructurales que he usado antes](https://developer.nvidia.com/cudnn)Ofrecer fragmentos de código relevantes de artículos anteriores
### [Generar automáticamente enlaces a publicaciones relacionadas](/blog/building-a-lawyer-gpt-for-your-blog-part3)
Mantener mi estilo de escritura y profundidad técnica[A diferencia de los asistentes genéricos de escritura de IA, nuestro sistema está basado en contenido pasado real, por lo que no sugerirá cosas inconsistentes con lo que ya he escrito.](https://qdrant.tech/)Sinopsis de la serie[Esto es lo que cubriremos en las próximas semanas:](https://github.com/pgvector/pgvector)).
### [Parte 1 (This Post): Introducción y Arquitectura](/blog/building-a-lawyer-gpt-for-your-blog-part4)
Estableceremos lo que estamos construyendo y por qué, además de cubrir las decisiones arquitectónicas.
### [Parte 2: Configuración de la GPU y CUDA en C#](/blog/building-a-lawyer-gpt-for-your-blog-part5)
Cómo configurar Windows para cargas de trabajo de IA aceleradas por GPU, instalación[CUDA](https://docs.microsoft.com/en-us/dotnet/desktop/wpf/), [cuDNN](https://avaloniaui.net/), y probando que C# realmente puede ver y utilizar su GPU.[Parte 3: Comprender los embebidos y las bases de datos vectoriales](https://dotnet.microsoft.com/en-us/apps/maui)Inmersión profunda en lo que en realidad son incrustaciones, cómo permiten la búsqueda semántica, y la elección de la base de datos vectorial derecha (spoiler: probablemente utilizaremos
### [Qdrant](/blog/building-a-lawyer-gpt-for-your-blog-part6)
o[pgvector](https://onnxruntime.ai/), [Parte 4: Construcción del oleoducto de ingestión](https://github.com/ggerganov/llama.cpp)Procesar archivos Markdown, estrategias inteligentes de troceado (¡no puedes dividirlos en párrafos!) y generar incrustaciones para todo nuestro contenido.
### [Parte 5: El cliente de Windows](/blog/building-a-lawyer-gpt-for-your-blog-part7)
Elección del marco adecuado (
### [WPF](/blog/building-a-lawyer-gpt-for-your-blog-part8)
Avalonia
## , o
MAUI
### ?), construyendo la interfaz de usuario, y haciéndolo realmente agradable de usar.
Parte 6: Integración local de la LLM
1. **Modelos de ejecución local utilizando**ONNX Runtime
2. **llama.cpp**encuadernaciones u otros enfoques.
3. **Haciendo pleno uso de ese A4000!**Parte 7: Generación de contenido e ingeniería rápida
4. **Reunirlo todo: búsqueda semántica de contenido relevante, gestión de ventanas de contexto, ingeniería rápida para la asistencia de escritura y generación de sugerencias coherentes.**Parte 8: Características avanzadas y despliegue de producción
5. **Auto-enlace a publicaciones relacionadas, verificación de la consistencia del estilo, sugerencias de fragmentos de código, y hacer que el sistema realmente útil para la escritura diaria.**¿Por qué RAG?
### Antes de sumergirnos en la arquitectura, vamos a hablar de por qué RAG (Retrieval Augmented Generation) es el enfoque correcto aquí.
El problema con el ajuste fino
Usted podría pensar: "¿Por qué no simplemente afinar un LLM en todos los posts del blog?" Hay varios problemas con eso:
1. Costo & Complejidad
2. - El ajuste es caro (tanto en computación como en esfuerzo)
3. Estanqueidad
4. - Cada nuevo post de blog significa readiestramiento
5. Caja negra
- Difícil de entender lo que el modelo "aprendió"
- ✅ 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)
## Alucinación
- No hay garantía de que el modelo no se inventará las cosas
```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
```
### Sin citaciones
- No puedo rastrear fácilmente las respuestas a las fuentes.
- ¿Cómo RAG resuelve esto
- RAG combina lo mejor de ambos mundos: el poder de los LLM con la precisión de la búsqueda para crear una generación de contenido consciente del contexto.
- El flujo es:
- El usuario comienza a escribir (por ejemplo, "Construyendo una API REST con ASP.NET Core...")
- El sistema encuentra artículos semánticos similares en el pasado
**El sistema alimenta trozos relevantes como contexto del LLM**LLM genera sugerencias/continuaciones basadas en contenidos pasados
### El sistema ofrece sugerencias con referencias a los puestos de origen
Esto significa:
Arquitectura de sistemas
Permíteme desglosar los componentes clave que vamos a construir:
- 1.
- Gasoducto de Ingestión de Markdown
**Este componente:**Lee los archivos de marca desde el directorio del blog
- [Extrae metadatos (título, categorías, fecha, conteo de palabras)](https://www.sbert.net/)Secciona inteligentemente el contenido (conservando bloques de código para su reutilización)
- Identifica patrones estructurales (cómo organizo los puestos)
- [Rastrea la información de la fuente para la generación de citas](https://huggingface.co/BAAI/bge-base-en-v1.5)Desafío clave
### : Recortar la estrategia importa enormemente.
Demasiado pequeño y pierdes contexto.
**Demasiado grande y desperdicias la ventana de contexto del LLM.**Necesitamos trozos que sean semánticamente significativos: un pensamiento completo o una sección, no rupturas arbitrarias de párrafos.
- **[2.](https://qdrant.tech/)**Modelo de empotrado
- **[Las incrustaciones son la magia que hace que la búsqueda semántica funcione.](https://github.com/pgvector/pgvector)**Un modelo de incrustación toma texto y lo convierte en un vector de alta dimensión (array de números) que captura el significado semántico.
- **[Conceptos similares terminan "cerrados" en el espacio vectorial, incluso si usan palabras diferentes.](https://weaviate.io/)**Por ejemplo:
- **["migración de bases de datos" y "actualización del esquema DB" tendrían incrustaciones similares](https://www.trychroma.com/)**"gato" y "kitten" estarían más cerca que "gato" y "base de datos"
Elección de la tecnología
### Probablemente usaremos cualquiera de los dos:
transformadores de frases
**[modelos (pueden ejecutarse a través de 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
**[Modelos de integración de OpenAI (a través de API)](https://avaloniaui.net/)**
- ✅ Cross-platform (XAML-based)
- ✅ Modern, actively developed
- ✅ Similar to WPF
- ❌ Smaller ecosystem
**[Modelos BGE](https://dotnet.microsoft.com/en-us/apps/maui)**
- ✅ Cross-platform
- ✅ Microsoft-backed
- ❌ Still maturing
- ❌ More mobile-focused
(fuente abierta de última generación)**3.[Base de datos vectorial](https://github.com/Kinnara/ModernWpf)**La base de datos de vectores almacena incrustaciones y permite una búsqueda rápida de similitud.**Cuando escribes sobre "Componer Docker", encuentra el contenido más semánticamente similar de K en el pasado - no sólo coincidencias de palabras clave, sino material relacionado conceptualmente.**Elección de la tecnología
### Vamos a evaluar:
Qdrant
- - Moderno, escrito en Rust, excelente cliente de C#, Docker-friendly
- pgvector
- - Extensión para PostgreSQL (ya estamos usando Postgres!)
- Tejido
**- Otra opción sólida con buen soporte .NET**:
**[Croma](https://onnxruntime.ai/)**
- - Popular en tierra de Python, menos en C#
- Me inclino hacia Qdrant por su simplicidad y rendimiento, o pgvector para mantener todo en Postgres.
- 4.
- Cliente de Windows
**[Necesitamos una buena interfaz de usuario para escribir con ayuda de IA.](https://github.com/ggerganov/llama.cpp)Piensa en el editor de paneles divididos con sugerencias.**
- Opciones:[WPF (Windows Presentation Foundation)](https://github.com/SciSharp/LLamaSharp))
- Avalonia
- MAUI (UI de aplicaciones multiplataforma)
- Ya que estamos centrados en Windows y quiero algo estable, me inclino hacia
**[WPF con](https://github.com/dotnet/TorchSharp)**
- Interfaz de usuario de WPF moderna
- o
- Avalonia
para ese potencial multiplataforma.**5.**Integración local de la LLM
### Aquí es donde brilla la A4000 GPU.
Queremos ejecutar el LLM localmente para:
- Privacidad (no se envían datos a APIs)
- Velocidad (la inferencia local es rápida)
- Coste (sin tarifas API)
- Control (elegimos el modelo)
Opciones tecnológicas
- ONNX Runtime
- Convertir modelos a formato ONNX
- Excelente aceleración GPU
- C# soporte nativo
### Rechazo: No todos los modelos se convierten bien
llama.cpp
- fijaciones
- Librería C++ con enlaces C# (
- LLAMASharp
- Soporta CUDA
- Soporte de modelo amplio (Llama, Mistral, etc.)
Desarrollo muy activo
## TorchSharp
Encuadernaciones PyTorch para .NET
1. **Mayor flexibilidad**Curva de aprendizaje Steeper
2. **Me inclino hacia**LLAMASharp
3. **por su madurez y facilidad de uso con modelos populares.**6.
4. **Context Window Management & Prompt Engineering**Los LLM tienen ventanas de contexto limitadas (por ejemplo, tokens 4K, 8K, 32K).
5. **Tenemos que:**Recuperar el contenido pasado más relevante (top K de la búsqueda de vectores)
## Ajustarlas a la ventana de contexto con el borrador actual
Estructurar la solicitud de asistencia por escrito
### Deja espacio para las sugerencias generadas
- **Esto es más complicado de lo que parece.**Vamos a explorar estrategias como:
- **Selección de K dinámica basada en lo que está escribiendo actualmente**Recalificación de trozos recuperados por relevancia
### Compresión inteligente del contexto
- **[Incitación de múltiples tomas con ejemplos de publicaciones anteriores](https://onnxruntime.ai/)**7.**[Generación de enlaces y citas](https://github.com/SciSharp/LLamaSharp)**Cada trozo necesita metadatos:
- **[Archivo/post de origen](https://dotnet.microsoft.com/en-us/apps/machinelearning-ai/ml-dotnet)**Posición en el documento original
- **Fecha de publicación**Categorías
### Fragmentos de código utilizados
- **[Cuando el LLM genera sugerencias, automáticamente creamos enlaces de marcado hacia abajo a las publicaciones de origen e identificamos patrones de código reutilizables.](https://qdrant.tech/)**¿ Qué hace que esto sea diferente?**[Hay un montón de tutoriales de RAG por ahí, pero esta serie será diferente:](https://github.com/pgvector/pgvector)**C# Primero
### - La mayoría de los ejemplos RAG están en Python.
- **Vamos a completar .NET**Windows y GPU**- Aprovechamiento de NVIDIA CUDA en Windows, no Linux/WSL**Producción lista**[- No sólo la prueba de concepto, sino el código real utilizable](https://avaloniaui.net/)**Dominio específico
### - Optimizado para asistencia de escritura de blog, no generación de contenido genérico
- **[Explicaciones profundas](https://github.com/xoofx/markdig)**- En realidad explicaremos el "por qué" detrás de las decisiones
- **[Tecnologías que usaremos](https://www.docker.com/)**Aquí está la pila de tecnología que estoy planeando:
- **[Marco básico](https://docs.microsoft.com/en-us/ef/core/)**.NET 9
### (últimos en el momento de redactar el presente informe)
- **[C# 13](https://developer.nvidia.com/cuda-toolkit)- Características del lenguaje moderno**Bibliotecas AI/ML
- **[ONNX Runtime](https://developer.nvidia.com/cudnn)**o
## LLAMASharp
- Inferencia LLM
### Microsoft.ML
- **- Potencialmente para algunas tareas**Transformers de sentencia vía ONNX
- **- Incrustaciones**Base de datos vectorial
- **Qdrant**o
- **pgvector**- Por determinar
### Marco de la interfaz de usuario
- **WPF**con
- **ModernWPF**o
- **Avalonia**- Interfaz de usuario de escritorio moderna
### Herramientas de apoyo
- **Markdig**- Ya estoy usando esto para el análisis de marcos.
- **Docker**- Para la ejecución de Qdrant u otros servicios
- **Marco básico de las entidades**- Si usamos pgvector
- **Apilador GPU**CUDA
### 12.x
- **(últimos en el momento de redactar el presente informe)**cuDNN
- **- Primitivos de aprendizaje profundo**Consideraciones sobre el desempeño
- **Diferentes configuraciones de hardware tendrán diferentes capacidades:**Con 8 GB de VRAM (mínimo)
- **Tamaño del modelo**: Modelos de parámetros 7B con cuantificación Q4
## Procesamiento por lotes
: Procesamiento de incrustaciones en lotes más pequeños
1. Gestión de memoria
2. : Se requiere una monitorización cuidadosa de la VRAM
3. Funciona bien para
4. : Asistente de escritura, generación de incrustaciones
5. Con 12 GB + VRAM (Comfortable)
6. Tamaño del modelo
: 7B con cuantificación de mayor calidad (Q5/Q6)
## Procesamiento por lotes
: Lotes más grandes para un rendimiento más rápido**[También se puede ejecutar](/blog/building-a-lawyer-gpt-for-your-blog-part2)**: Algunos modelos 13B con cuantificación agresiva
- Con 16GB+ VRAM (Mi configuración)
- Tamaño del modelo
- : Modelos de parámetros 7B-13B cómodamente
- Procesamiento por lotes
- : Lotes completos, limitaciones mínimas
Inferencia rápida
## : Tiempos de respuesta de subsegundos
Headroom
- **: Puede experimentar con diferentes modelos**Solo CPU (retroceso)
- **Todo funciona.**, sólo más lento
- **Incrustaciones**: 5-10x más lento que la GPU
- **Inferencia de LLM**: 10-50x más lento que la GPU
- **Aún utilizable**: ¡Para un asistente de escritura con paciencia!
Enfoque para el desarrollo
## Vamos a construir esto incrementalmente:
Comience con los componentes más simples (lectura de marcadores, troceado)
Añadir generación de incrustación (podría comenzar con API-basada antes de ir local)
Obtener trabajo de búsqueda de vectores
Construir interfaz de usuario básica
## Integrar LLM
- **Polaco y optimizar**Cada parte será desplegada y probada por sí sola.
- [Nada de pesadillas de integración.](/blog/building-a-lawyer-gpt-for-your-blog-part2)
- [¿Qué sigue?](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [In](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Parte 2: Configuración de la GPU y CUDA en C#](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [, nos pondremos manos a la obra con la configuración de la GPU:](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [Instalar CUDA y cuDNN en Windows](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Creación de un entorno de desarrollo](/blog/building-a-lawyer-gpt-for-your-blog-part8)
## Escribir un programa C# simple para verificar el acceso a la GPU
Realizar una prueba de inferencia básica con ONNX Runtime
- [Benchmarking nuestro A4000 para entender lo que podemos hacer](https://onnxruntime.ai/)
- [Esto puede parecer básico, pero conseguir la pila de GPU correcta es crucial.](https://github.com/SciSharp/LLamaSharp)
- [He perdido horas de depuración de problemas que se redujeron a desajustes de versiones o DLLs faltantes.](https://qdrant.tech/documentation/)
- [¿Por qué importa esto?](https://www.sbert.net/)
- [Más allá de ser un proyecto genial, este enfoque tiene aplicaciones reales:](https://www.anthropic.com/index/contextual-retrieval)
Documentación técnica[- Mantener un estilo consistente a través de grandes conjuntos de documentos](/blog/building-a-lawyer-gpt-for-your-blog-part2)!