Curso de LLMs Locales, RAG y Bases de Datos Vectoriales

Comprender cómo un LLM procesa tokens, contexto, prompt, historial y generación incremental.

Diferenciar modelos base, instruct, chat, reasoning, code, multimodal, embedding y reranker.

Entender parámetros, tamaño de modelo, contexto, vocabulario, tokenizer y formato de prompt.

Revisar sampling: temperature, top_p, top_k, min_p, repeat penalty, max tokens, stop sequences y seed.

Diferenciar inferencia batch, streaming, offline, online, multiusuario y serving de alto rendimiento.

Comprender KV cache, memoria de activaciones, VRAM, RAM, offloading, throughput y tokens por segundo.

Evaluar familias de modelos habituales como Llama, Qwen, Mistral, Gemma, DeepSeek, Phi, CodeLlama, Granite o equivalentes.

Revisar licencias, condiciones de uso, restricciones comerciales, atribución y obligaciones internas.

Diferenciar modelos generalistas, modelos de código, modelos multilingües, modelos de razonamiento y modelos compactos.

Evaluar idioma, contexto, benchmarks, rendimiento real, comunidad, soporte de herramientas y compatibilidad con serving.

Analizar por qué dos modelos similares pueden comportarse de forma muy distinta en RAG.

Probar modelos con tareas propias: resumen, extracción, preguntas documentales, clasificación, código o soporte.

Evitar elegir modelos solo por ranking público sin validarlos con datos, idioma y casos de uso propios.

Crear una matriz de selección por calidad, licencia, coste, tamaño, hardware, privacidad y soporte.

Documentar versión exacta del modelo, fuente, hash, cuantización, contexto, prompt template y configuración usada.

Calcular requisitos aproximados de RAM, VRAM y disco según tamaño del modelo, cuantización y longitud de contexto.

Diferenciar inferencia CPU, GPU, Apple Silicon, CUDA, ROCm, Metal, Vulkan y backends disponibles según herramienta.

Entender cómo afecta la cuantización a memoria, velocidad, precisión y calidad percibida.

Comparar modelos de 3B, 7B/8B, 14B, 27B, 70B y superiores desde una perspectiva empresarial realista.

Definir cuándo conviene usar modelos pequeños con buen RAG y cuándo un modelo grande aporta valor.

Evaluar coste de hardware frente a coste de APIs externas, mantenimiento interno, consumo energético y operación.

Comprender qué es cuantizar un modelo y por qué reduce memoria o habilita ejecución en hardware limitado.

Diferenciar formatos y niveles habituales: FP16, BF16, INT8, Q8, Q6, Q5, Q4, AWQ, GPTQ, GGUF y otros.

Usar modelos GGUF con llama.cpp, Ollama o herramientas compatibles.

Analizar impacto de cuantización en razonamiento, extracción, respuestas largas, formato JSON y seguimiento de instrucciones.

Revisar uso de offloading a GPU, número de capas en GPU, contexto, batch, paralelismo y caché.

Evitar elegir siempre la cuantización más pequeña si degrada demasiado la respuesta.

Identificar cuellos de botella: VRAM insuficiente, CPU lenta, disco, transferencia CPU-GPU, contexto largo y concurrencia.

Preparar recomendaciones para workstation, laboratorio, servidor interno, entornos air-gapped y cloud privado.

Documentar configuración de hardware y cuantización como parte de la trazabilidad técnica del sistema.

Instalar y configurar Ollama en workstation o servidor de laboratorio.

Descargar, ejecutar, listar, actualizar y limpiar modelos locales desde comandos y API.

Probar generación, chat, embeddings y consumo desde terminal, Python, clientes HTTP y herramientas compatibles.

Configurar modelos mediante Modelfile, system prompt, parámetros, variantes internas y perfiles de uso.

Usar compatibilidad con APIs tipo OpenAI para integrar herramientas externas cuando el caso lo permite.

Ejecutar modelos de embeddings localmente para pipelines RAG de laboratorio.

Proteger el servicio local cuando se expone en red corporativa.

Compilar o instalar llama.cpp según sistema operativo y hardware disponible.

Ejecutar modelos GGUF desde línea de comandos para pruebas rápidas y benchmarking.

Levantar llama-server como servicio local compatible con APIs de chat.

Configurar contexto, threads, batch, GPU layers, paralelismo, puerto y parámetros de inferencia.

Usar LM Studio como laboratorio visual para probar modelos, parámetros, prompts y APIs locales.

Desplegar Open WebUI u otras interfaces para facilitar pruebas con usuarios internos.

Gestionar usuarios, permisos, logs, historial, modelos disponibles y exposición de datos.

Evitar que interfaces de laboratorio se conviertan en soluciones productivas sin autenticación, aislamiento, gobierno y observabilidad.

Comprender cuándo vLLM aporta valor frente a Ollama, llama.cpp o herramientas de escritorio.

Desplegar un modelo con servidor compatible con OpenAI API para aplicaciones internas.

Configurar batch, streaming, paralelismo, uso de GPU, contexto, API key y parámetros del servidor.

Evaluar throughput, latencia, concurrencia, coste por usuario interno y saturación de recursos.

Usar vLLM para escenarios multiusuario, APIs internas, prototipos de producción y cargas mayores.

Revisar soporte de modelos Hugging Face, tool calling, structured outputs, reasoning parsers y multimodalidad según modelo.

Controlar logs de prompts y outputs para evitar fugas de datos sensibles.

Integrar vLLM con balanceadores, Docker, Kubernetes, API gateways y autenticación corporativa.

Comparar rendimiento de vLLM, Ollama y llama.cpp con el mismo caso de uso.

Diseñar endpoints internos para chat, embeddings, modelos, salud del servicio, métricas y administración.

Crear streaming de respuestas para mejorar experiencia de usuario en aplicaciones internas.

Gestionar timeouts, colas, límites por usuario, concurrencia, backpressure y reintentos.

Separar servicio de inferencia, API de negocio, retrieval, ingesta y frontend.

Evitar exponer directamente el servidor LLM a usuarios finales o redes no confiables.

Documentar configuración de serving, parámetros, modelo cargado, límites de uso y procedimiento de arranque.

Comprender qué son los embeddings y cómo representan documentos, consultas, imágenes o fragmentos como vectores.

Diferenciar embeddings para búsqueda, clasificación, clustering, similitud, recomendación y recuperación multimodal.

Seleccionar modelos de embeddings locales o remotos según idioma, dominio, dimensión, coste y rendimiento.

Evaluar modelos como BGE, E5, GTE, nomic, Qwen Embedding u opciones equivalentes.

Entender dimensión vectorial, normalización, distancia coseno, dot product y distancia euclídea.

Medir impacto del modelo de embeddings en calidad de recuperación antes de cambiar el LLM generador.

Probar embeddings multilingües para documentación en español, inglés o entornos mixtos.

Revisar modelos de embeddings y rerankers además del modelo generador.

Entender qué aporta un reranker frente a una búsqueda vectorial simple.

Evaluar rerankers locales y remotos según coste, latencia, idioma, precisión y restricciones de datos.

Diseñar estrategias multi-stage: retrieve amplio, filtrar, rerankear, comprimir y generar.

Gestionar versiones de embeddings y reindexado cuando cambia el modelo.

Evitar mezclar embeddings de modelos distintos dentro de la misma colección sin estrategia.

Crear criterios para elegir top_k, score threshold, filtros, reranking y fallback.

Documentar modelo de embeddings, dimensión, distancia, versión, corpus indexado y fecha de generación.

Comprender colección, punto, vector, payload, metadata, índice, distancia, top_k y filtro.

Diferenciar librería vectorial, base vectorial local, servicio vectorial gestionado y extensión SQL vectorial.

Evaluar Chroma, Qdrant, Milvus, FAISS, pgvector, Weaviate, Elasticsearch/OpenSearch y alternativas.

Usar Chroma para prototipos RAG, asistentes internos pequeños, local-first y validaciones rápidas.

Evaluar límites de Chroma en escalado, concurrencia, gobierno, observabilidad y operación.

Usar Qdrant cuando son críticos filtros por metadata, payload indexes, búsqueda híbrida y operación controlada.

Diseñar colecciones Qdrant con vectores densos, sparse vectors, payload estructurado y filtros por permisos.

Usar Milvus cuando el escenario exige escala, arquitectura distribuida, grandes volúmenes y consultas concurrentes.

Comprender colecciones, particiones, índices, scalar fields, dense vectors, sparse vectors y búsqueda híbrida en Milvus.

Usar FAISS como librería eficiente para búsqueda de similitud en memoria, notebooks, batch o prototipos controlados.

Usar pgvector cuando conviene mantener vectores junto a datos relacionales en PostgreSQL.

Diseñar esquemas SQL con embeddings, metadatos, permisos, documentos y trazabilidad.

Comparar HNSW, IVF, PQ, quantization, payload indexes y trade-offs entre precisión, memoria y velocidad.

Decidir según escala, persistencia, filtros, búsqueda híbrida, HA, cloud, on-premise, backups y observabilidad.

Crear matriz de decisión para elegir base vectorial según prototipo, equipo, datos, permisos, volumen y madurez operativa.

Diseñar pipeline de ingesta desde PDF, DOCX, HTML, Markdown, TXT, CSV, Excel, correos y wikis internas.

Conectar SharePoint, Google Drive, Confluence, Jira, GitHub, GitLab, S3, DMS o file shares.

Extraer texto manteniendo estructura: títulos, secciones, tablas, listas, notas, páginas y referencias.

Gestionar OCR cuando hay PDFs escaneados, imágenes o documentación técnica no accesible.

Limpiar ruido: cabeceras, pies, numeración, marcas de agua, duplicados y contenido irrelevante.

Preservar metadatos: fuente, URL, fecha, owner, permisos, versión, idioma, tipo y confidencialidad.

Crear identificadores estables para documento, sección, chunk y versión.

Diseñar reingesta incremental para cambios de documentos sin reindexar todo.

Respetar ACLs, grupos, propietarios, clasificación y herencia de permisos del origen.

Gestionar documentos borrados, movidos, renombrados, duplicados, obsoletos y contradictorios.

Normalizar contenido procedente de HTML, PDF, Markdown, tickets, issues, wikis y repositorios.

Crear informes de ingesta con errores, documentos procesados, documentos omitidos, descartes y avisos.

Evitar ingestar documentación no autorizada, sin owner, sin limpieza documental o sin política de permisos.

Diseñar mapa de fuentes para priorizar alto valor y bajo riesgo.

Preparar datasets documentales con trazabilidad completa hacia fuente original y versión publicada.

Comprender por qué el chunking afecta directamente a la calidad del RAG.

Comparar chunking por tamaño fijo, párrafo, encabezado, semántico, tabla, página y estructura documental.

Definir overlap adecuado según tipo de documento y longitud de respuesta esperada.

Mantener jerarquía documental: documento, capítulo, sección, subsección, tabla y fragmento.

Diseñar chunks con contexto suficiente sin mezclar temas distintos.

Tratar tablas, contratos, manuales técnicos, FAQs, políticas internas, código y tickets de forma diferenciada.

Añadir metadata contextual para mejorar filtros, trazabilidad y respuestas.

Gestionar documentos largos con jerarquía, resúmenes por sección y recuperación contextual.

Diseñar estrategias de parent-child retrieval, summaries, contextual chunks y recuperación por secciones.

Evitar chunks gigantes que saturan contexto o chunks pequeños que pierden significado.

Evaluar chunking con métricas de recuperación y pruebas reales de usuario.

Mantener relación entre chunk, documento, fuente, sección, página, versión y permisos.

Reindexar cuando cambian chunking, embeddings, metadatos relevantes o estructura documental.

Preparar reglas específicas para tablas, anexos, normativas, manuales, contratos y documentación técnica.

Documentar estrategia de segmentación para que el sistema pueda auditarse y evolucionar.

Diseñar recuperación semántica con top_k, score threshold, filtros y metadata.

Combinar búsqueda densa con búsqueda keyword, sparse vectors o full-text search.

Usar filtros por permisos, fecha, idioma, tipo documental, departamento, cliente o versión.

Implementar reranking para ordenar resultados recuperados según relevancia real para la consulta.

Diseñar query rewriting para mejorar preguntas ambiguas o mal formuladas.

Usar multi-query retrieval para cubrir varias formulaciones de una misma intención.

Aplicar contextual compression para reducir ruido antes de pasar contexto al LLM.

Crear prompts que separen rol, tarea, contexto recuperado, pregunta, formato y límites.

Indicar al modelo que responda solo con información del contexto cuando el caso lo requiere.

Diseñar respuestas con citas, fragmentos, fuentes, enlaces internos o referencias a documento.

Pedir al modelo que declare incertidumbre cuando el contexto no contiene respuesta suficiente.

Crear formatos de salida: resumen, tabla, lista de pasos, respuesta ejecutiva, análisis técnico o JSON.

Evitar prompts que animan al modelo a completar huecos con conocimiento general no autorizado.

Crear fallback cuando no hay documentos relevantes suficientes.

Probar el prompt y el retrieval con preguntas con respuesta, sin respuesta, ambiguas, maliciosas y multi-hop.

Diferenciar naive RAG, advanced RAG, agentic RAG, GraphRAG, multi-hop RAG, corrective RAG y adaptive RAG.

Implementar routing por tipo de consulta, dominio, fuente documental o nivel de riesgo.

Diseñar RAG por permisos, tenant, departamento, idioma y clasificación documental.

Incorporar memoria conversacional sin romper trazabilidad ni mezclar usuarios.

Evaluar cuándo GraphRAG o grafos de conocimiento aportan valor frente a RAG vectorial.

Usar LangChain para construir chains, retrievers, prompt templates, tool calling y conectores.

Usar LlamaIndex para ingesta, índices, query engines, chat engines y estructura documental.

Comparar frameworks frente a implementación propia en Python.

Integrar modelos locales servidos con Ollama, llama.cpp o vLLM dentro de frameworks.

Integrar Chroma, Qdrant, Milvus, FAISS o pgvector como vector stores.

Controlar abstracciones para no perder visibilidad sobre retrieval, prompts, latencia y errores.

Crear API backend para exponer un asistente RAG a aplicaciones internas.

Diseñar endpoints para chat, búsqueda, ingesta, feedback, historial, fuentes y administración.

Integrar con Teams, Slack, portales internos, Jira, Confluence, SharePoint, DMS o intranet cuando procede.

Evitar copiar ejemplos de documentación sin adaptarlos a seguridad, permisos, datos reales y operación corporativa.

Clasificar documentos antes de indexarlos: público, interno, confidencial, sensible o restringido.

Aplicar control de permisos en recuperación, no solo en la interfaz de usuario.

Evitar que un usuario recupere chunks de documentos que no puede consultar en origen.

Proteger prompts, respuestas, logs, embeddings, metadatos y artefactos generados.

Evaluar si los embeddings pueden contener información sensible o inferible.

Diseñar aislamiento por tenant, departamento, cliente, entorno, corpus o nivel de confidencialidad.

Aplicar cifrado en tránsito, cifrado en reposo, secrets management y rotación de credenciales.

Gestionar datos personales, propiedad intelectual, contratos, documentación legal o información estratégica.

Crear política de retención para logs, conversaciones, índices, documentos, trazas y feedback.

Controlar logs de prompts, outputs y documentos recuperados para evitar exposición innecesaria.

Diseñar autenticación, autorización, sesiones, permisos y límites por usuario.

Preparar red teaming básico frente a prompt injection, data leakage, jailbreaks, queries maliciosas y extracción de contexto.

Incorporar revisión humana para respuestas críticas, legales, financieras, contractuales o de alto impacto.

Documentar riesgos, mitigaciones, propietarios, fuentes de datos y criterios de escalado.

Validar que seguridad, privacidad y trazabilidad se mantienen también en ingesta, evaluación, observabilidad y backups.

Definir datasets de evaluación con preguntas, respuestas esperadas, documentos fuente y casos sin respuesta.

Medir calidad de retrieval: contexto relevante, documentos correctos, cobertura y ruido.

Medir groundedness para comprobar si la respuesta está respaldada por fuentes recuperadas.

Medir answer relevance para comprobar si la respuesta contesta realmente a la pregunta.

Evaluar alucinaciones, omisiones, contradicciones, formato, tono, utilidad y uso correcto de fuentes.

Comparar modelos locales, prompts, chunking, embeddings, top_k, búsqueda híbrida y rerankers con evidencias.

Usar herramientas como Ragas, TruLens, DeepEval, PromptTest, Phoenix, LangSmith u opciones equivalentes.

Incorporar revisión humana en preguntas críticas o de alto impacto.

Crear quality gates antes de desplegar cambios de modelo, prompt, índice, embeddings o base documental.

Registrar queries, documentos recuperados, scores, modelo, latencia, tokens, errores y feedback de usuario.

Crear trazabilidad desde pregunta hasta chunks, prompt final, respuesta y fuentes citadas.

Medir latencia por componente: retrieval, reranking, generación, postprocesado y base vectorial.

Monitorizar uso por usuario, departamento, caso de uso, coste estimado y tasa de error.

Detectar degradación por cambios de documentos, embeddings, modelo, prompt o configuración.

Crear dashboards para operación técnica, revisión metodológica y reporting ejecutivo.

Medir throughput, latencia, tokens por segundo, concurrencia, memoria, uso de GPU y tasa de error.

Optimizar parámetros de inferencia: contexto, batch, paralelismo, cuantización, streaming y cache.

Optimizar retrieval: índices, filtros, payload indexes, top_k, reranking y compresión de contexto.

Reducir coste mediante modelos pequeños, embeddings locales, caching y selección inteligente de rutas.

Implementar response caching y semantic caching cuando el caso de uso lo permite.

Diseñar colas, límites de concurrencia, timeouts, backpressure y separación de servicios.

Crear Dockerfiles para API, ingesta, workers y servicios auxiliares.

Levantar stack local con Docker Compose: LLM server, vector DB, API, frontend y observabilidad.

Gestionar volúmenes para modelos, índices, documentos, logs y snapshots.

Configurar variables de entorno, secrets, redes internas, puertos, healthchecks y restart policies.

Desplegar Qdrant, Milvus, PostgreSQL+pgvector o Chroma en entorno controlado.

Diseñar despliegue en Kubernetes para LLM serving, API, vector DB, workers y frontends.

Configurar nodos GPU, device plugins, tolerations, affinity, límites de recursos, ingress, TLS y API gateway.

Gestionar actualizaciones blue/green o canary para modelos, prompts, embeddings, índices y APIs.

Evitar optimizaciones prematuras o despliegues complejos sin métricas, operación, seguridad y mantenimiento definidos.

Diferenciar asistente RAG, agente con herramientas, workflow determinista y agente autónomo.

Conectar LLM local con herramientas internas: búsqueda, SQL, APIs, tickets, ficheros o scripts.

Definir acciones permitidas, acciones restringidas y acciones que requieren aprobación humana.

Combinar RAG con tools para responder y ejecutar tareas controladas.

Usar MCP u otros patrones de tool access cuando el proyecto lo requiere.

Registrar tool calls, argumentos, resultados, errores y decisiones del agente.

Procesar PDFs con tablas, imágenes, diagramas, planos, capturas y documentación técnica.

Usar OCR y modelos multimodales cuando el texto extraído no es suficiente.

Crear embeddings para texto, imagen o datos multimodales según herramienta y caso.

Gestionar tablas con extracción estructurada, Markdown, CSV o JSON.

Diseñar respuestas que indiquen si una conclusión procede de texto, tabla, imagen o metadato.

Diseñar RAG para soporte IT con runbooks, FAQs, tickets históricos y documentación interna.

Diseñar RAG para legal, RRHH, ventas, ingeniería, operaciones, finanzas y compliance con criterios de seguridad diferentes.

Priorizar casos por valor, riesgo, calidad documental, facilidad de ingesta, sponsor y capacidad de mantenimiento.

Evitar agentes que modifican sistemas internos sin trazabilidad, validación, permisos y control humano.

Definir owners de modelos, prompts, documentos, índices, bases vectoriales, conectores y evaluación.

Crear proceso de alta, actualización, retirada y auditoría de fuentes documentales.

Establecer revisión periódica de calidad de respuestas, cobertura documental y satisfacción de usuarios.

Gestionar versiones de modelos, embeddings, prompts, pipelines, índices, bases vectoriales y datasets de evaluación.

Documentar arquitectura, decisiones técnicas, límites, riesgos y criterios de uso.

Crear catálogo de asistentes RAG aprobados, pilotos, experimentales y retirados.

Definir soporte N1/N2/N3 para usuarios, incidencias, errores de datos y problemas de infraestructura.

Medir valor: consultas resueltas, tiempo ahorrado, satisfacción, reducción de tickets y mejora de onboarding.

Evitar soluciones RAG abandonadas con documentos obsoletos, índices sin mantenimiento y prompts sin propietario.

Diagnosticar respuestas malas por modelo insuficiente, prompt débil, retrieval pobre o documentos mal procesados.

Detectar embeddings incompatibles, dimensiones incorrectas, colecciones mezcladas y metadatos incoherentes.

Resolver problemas de contexto largo, truncamiento, respuestas incompletas, formato roto o citas incorrectas.

Investigar latencia alta por modelo, reranker, top_k, base vectorial, hardware o red.

Preparar runbooks para Ollama, llama.cpp, vLLM, Qdrant, Milvus, Chroma, pgvector, API propia y frontend.

Crear checklist de depuración antes de culpar al modelo o sustituir componentes sin evidencia.

Diseñar una solución corporativa completa con LLM local, RAG, base vectorial, API, evaluación y despliegue.

Seleccionar caso de uso, usuarios, fuentes documentales, restricciones de seguridad y objetivos medibles.

Elegir modelo generador local según idioma, calidad, licencia, tamaño, hardware y coste operativo.

Elegir modelo de embeddings y justificar dimensión, rendimiento, idioma y estrategia de versionado.

Seleccionar base vectorial entre Chroma, Qdrant, Milvus, FAISS, pgvector u opción equivalente.

Preparar entorno con Python, Docker, Git, servidor LLM, base vectorial, API y herramientas de evaluación.

Crear pipeline de ingesta documental con extracción, limpieza, OCR si procede, chunking, metadatos, permisos y logs.

Generar embeddings, insertar documentos en la base vectorial y validar trazabilidad hasta fuente original.

Implementar retrieval con filtros por metadata, permisos, top_k, score threshold, búsqueda híbrida o reranking.

Diseñar prompt RAG con contexto, límites, formato, fuentes, incertidumbre y rechazo cuando no hay evidencia.

Crear API interna con endpoint de chat, streaming, fuentes citadas, feedback y control de errores.

Añadir autenticación, permisos básicos, aislamiento de datos y protección de logs sensibles.

Implementar observabilidad con trazas, latencia, documentos recuperados, modelo usado, errores y feedback.

Evaluar calidad con dataset de preguntas, respuestas esperadas, groundedness, relevance y revisión humana.

Comparar al menos dos modelos locales, dos estrategias de chunking, dos configuraciones de retrieval o dos bases vectoriales.

Optimizar rendimiento, memoria, latencia, top_k, prompt, contexto, cuantización y coste de ejecución.

Crear despliegue reproducible con Docker Compose y documentación para sistemas.

Preparar política de mantenimiento: reingesta, backups, versionado, actualización de modelos y revisión de calidad.

Crear informe ejecutivo con arquitectura, riesgos, costes, métricas, límites y roadmap de evolución.

Presentar la solución final defendiendo privacidad, calidad, seguridad, rendimiento, gobierno y valor de negocio.