RAG significa Retrieval-Augmented Generation. Es una arquitectura que recupera información relevante de documentos o datos y la usa como contexto para responder.

¿Por qué usar bases de datos vectoriales?

Permiten buscar fragmentos similares semánticamente a una consulta, almacenando embeddings y metadatos para recuperar conocimiento útil en sistemas RAG.

¿Qué herramientas se trabajan?

El curso puede trabajar con Ollama, llama.cpp, vLLM, LM Studio, Open WebUI, Chroma, Qdrant, Milvus, FAISS, pgvector, LangChain, LlamaIndex y Docker.

¿Hace falta una GPU?

No siempre, pero es muy recomendable. Para modelos medianos y buen rendimiento se recomienda GPU dedicada con VRAM suficiente.

¿Puedo ejecutar modelos solo con CPU?

Sí, especialmente modelos pequeños o cuantizados, aunque la velocidad suele ser menor. El curso explica cuándo tiene sentido y qué límites existen.

GGUF es un formato habitual para modelos cuantizados compatibles con herramientas como llama.cpp, Ollama y otros entornos de inferencia local.

¿Qué diferencia hay entre Ollama y vLLM?

Ollama es muy cómodo para laboratorio, desarrollo local y uso sencillo. vLLM está más orientado a serving de alto rendimiento, concurrencia y despliegues de mayor escala.

¿Qué base vectorial debería usar?

Depende del caso. Chroma es muy útil para prototipos; Qdrant destaca en filtros y producción; Milvus en escala; FAISS en librería eficiente; pgvector en PostgreSQL.

¿Se trabaja búsqueda híbrida?

Sí. Se trabaja combinación de búsqueda semántica, keyword, sparse vectors, filtros y reranking para mejorar la relevancia de los resultados.

¿Incluye evaluación de calidad?

Sí. Se evalúan retrieval, groundedness, answer relevance, alucinaciones, latencia, coste, estabilidad y satisfacción del usuario.

¿Se puede usar con documentos internos?

Sí, siempre que se anonimizan o se tratan en entornos autorizados. El curso incluye permisos, metadatos, seguridad, privacidad y control de acceso.

¿Sirve para entornos air-gapped?

Sí. El curso contempla escenarios sin conexión externa, modelos locales, documentación interna, despliegues on-premise y control de dependencias.

¿Incluye agentes IA?

Sí. Se trabaja cómo combinar RAG local con herramientas y agentes controlados, incluyendo límites, permisos, trazabilidad y aprobación humana.

¿Qué entregable final crea el alumno?

Una solución RAG completa con LLM local, ingesta documental, base vectorial, API, evaluación, observabilidad, seguridad, Docker y documentación técnica.

¿Puede adaptarse a nuestra empresa?

Sí. Puede adaptarse a soporte interno, legal, RRHH, ventas, ingeniería, compliance, documentación técnica, operaciones, IT o conocimiento corporativo.

¿Puede bonificarse esta formación por FUNDAE?

Sí, esta formación puede ser bonificable hasta el 100% a través de FUNDAE, siempre que la empresa disponga de crédito formativo suficiente y se cumplan los requisitos de comunicación, asistencia y documentación exigidos.

Curso de LLMs Locales, RAG y Bases de Datos Vectoriales

Aprende con el curso de LLMs Locales, RAG y Bases de Datos Vectoriales para empresas hasta 100% bonificado, a medida para tu organización.

Totalmente práctico y aplicable

Formación en LLMs Locales, RAG y Bases de Datos Vectoriales a medida

100% bonificable a través de FUNDAE

Curso TUTORIZADO por expertos

Solicitar precio

Me interesa

Calcula mis créditos de FUNDAE

Solicitar precio

Calcula mis créditos de FUNDAE

Programa formativo

Temario del curso

Encuentra todo el temario del curso aquí.

Temario

Comprender qué es un LLM local y por qué una organización puede preferirlo frente a un modelo cloud.
Diferenciar modelo local, modelo privado, modelo open weights, modelo open source, modelo cuantizado y modelo servido internamente.
Entender qué problema resuelve RAG: conectar el LLM con documentación, datos y conocimiento específico de la empresa.
Diferenciar búsqueda semántica, búsqueda keyword, búsqueda híbrida, retrieval, reranking y generación final.
Identificar qué papel cumple una base de datos vectorial dentro de una arquitectura GenAI.
Analizar casos de uso: asistente documental, soporte interno, legal, IT, RRHH, ventas, ingeniería, compliance y conocimiento corporativo.
Reconocer límites: un LLM local no garantiza calidad, privacidad ni seguridad si la arquitectura está mal diseñada.
Evaluar trade-offs entre coste, rendimiento, latencia, precisión, mantenimiento, privacidad y experiencia de usuario.
Diferenciar prototipo local, piloto departamental, solución corporativa y despliegue productivo.
Preparar el caso base del curso: asistente privado sobre documentación corporativa con RAG y LLM local.

Comprender qué es un LLM local y por qué una organización puede preferirlo frente a un modelo cloud.
Diferenciar modelo local, modelo privado, modelo open weights, modelo open source, modelo cuantizado y modelo servido internamente.
Entender qué problema resuelve RAG: conectar el LLM con documentación, datos y conocimiento específico de la empresa.
Diferenciar búsqueda semántica, búsqueda keyword, búsqueda híbrida, retrieval, reranking y generación final.
Identificar qué papel cumple una base de datos vectorial dentro de una arquitectura GenAI.
Analizar casos de uso: asistente documental, soporte interno, legal, IT, RRHH, ventas, ingeniería, compliance y conocimiento corporativo.
Reconocer límites: un LLM local no garantiza calidad, privacidad ni seguridad si la arquitectura está mal diseñada.
Evaluar trade-offs entre coste, rendimiento, latencia, precisión, mantenimiento, privacidad y experiencia de usuario.
Diferenciar prototipo local, piloto departamental, solución corporativa y despliegue productivo.
Preparar el caso base del curso: asistente privado sobre documentación corporativa con RAG y LLM local.

¿Tienes dudas?

Estamos aquí para ayudarte

Reservar plaza

Tema 1: LLMs locales, RAG y bases vectoriales: visión global para empresa

Comprender qué es un LLM local y por qué una organización puede preferirlo frente a un modelo cloud.
Diferenciar modelo local, modelo privado, modelo open weights, modelo open source, modelo cuantizado y modelo servido internamente.
Entender qué problema resuelve RAG: conectar el LLM con documentación, datos y conocimiento específico de la empresa.
Diferenciar búsqueda semántica, búsqueda keyword, búsqueda híbrida, retrieval, reranking y generación final.
Identificar qué papel cumple una base de datos vectorial dentro de una arquitectura GenAI.
Analizar casos de uso: asistente documental, soporte interno, legal, IT, RRHH, ventas, ingeniería, compliance y conocimiento corporativo.
Reconocer límites: un LLM local no garantiza calidad, privacidad ni seguridad si la arquitectura está mal diseñada.
Evaluar trade-offs entre coste, rendimiento, latencia, precisión, mantenimiento, privacidad y experiencia de usuario.
Diferenciar prototipo local, piloto departamental, solución corporativa y despliegue productivo.
Preparar el caso base del curso: asistente privado sobre documentación corporativa con RAG y LLM local.

Tema 2: Fundamentos de modelos de lenguaje y arquitectura de inferencia

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 y throughput.
Analizar por qué dos modelos similares pueden comportarse de forma muy distinta en RAG.
Evaluar limitaciones de contexto, pérdida de instrucciones, alucinaciones y sensibilidad al prompt.
Entender diferencias entre modelos de propósito general y modelos especializados en código, razonamiento o embeddings.
Realizar ejercicio de comparación funcional entre varios modelos locales pequeños y medianos.

Tema 3: Hardware, GPU, CPU, VRAM y dimensionamiento

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.
Dimensionar equipo local para pruebas, workstation para desarrollo y servidor para varios usuarios.
Identificar cuellos de botella: VRAM insuficiente, CPU lenta, disco, transferencia CPU-GPU, contexto largo y concurrencia.
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 y mantenimiento interno.
Preparar recomendaciones para entornos air-gapped, laboratorios, servidores internos y despliegues cloud privados.
Realizar ejercicio de dimensionamiento de hardware para tres escenarios de empresa.

Tema 4: Modelos locales, licencias y criterios de selección

Evaluar familias de modelos habituales como Llama, Qwen, Mistral, Gemma, DeepSeek, Phi, CodeLlama 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.
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 y casos de uso propios.
Crear una matriz de selección por calidad, licencia, coste, tamaño, hardware, privacidad y soporte.
Revisar modelos de embeddings y rerankers además del modelo generador.
Documentar versión exacta del modelo, fuente, hash, cuantización y configuración usada.
Realizar ejercicio de selección de stack de modelos para una solución RAG corporativa.

Tema 5: Cuantización, GGUF y optimización de modelos

Comprender qué es cuantizar un modelo y por qué reduce memoria y puede mejorar velocidad.
Diferenciar formatos y niveles habituales: FP16, BF16, INT8, Q8, Q6, Q5, Q4, AWQ, GPTQ, GGUF y otros.
Entender el equilibrio entre reducción de tamaño y pérdida de calidad.
Usar modelos GGUF con llama.cpp, Ollama o herramientas compatibles.
Evaluar cuantizaciones distintas con las mismas preguntas y documentos.
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 y tamaño de batch.
Evitar elegir siempre la cuantización más pequeña por ahorrar memoria si degrada demasiado la respuesta.
Documentar configuración de cuantización como parte de la trazabilidad del sistema.
Realizar ejercicio de comparación entre modelos Q4, Q5, Q8 y FP16 cuando el hardware lo permita.

Tema 6: Ollama para laboratorio local y APIs compatibles

Instalar Ollama en workstation o servidor de laboratorio.
Descargar y ejecutar modelos locales mediante comandos simples.
Probar generación, chat, embeddings y API local desde terminal y clientes HTTP.
Configurar modelos mediante Modelfile, system prompt, parámetros y variantes internas.
Usar compatibilidad con APIs tipo OpenAI para integrar herramientas externas.
Ejecutar modelos de embeddings localmente para pipelines RAG.
Gestionar modelos instalados, versiones, espacio en disco y limpieza de artefactos.
Proteger el servicio local cuando se expone en red corporativa.
Integrar Ollama con Python, LangChain, LlamaIndex, Open WebUI u otras herramientas.
Realizar ejercicio de creación de laboratorio local con modelo generador y modelo de embeddings.

Tema 7: llama.cpp, llama-server y despliegue ligero

Compilar o instalar llama.cpp según sistema operativo y hardware disponible.
Ejecutar modelos GGUF desde línea de comandos para pruebas rápidas.
Levantar llama-server como servicio local compatible con APIs de chat.
Configurar contexto, threads, batch, GPU layers, paralelismo, puerto y parámetros de inferencia.
Analizar rendimiento en CPU, GPU y Apple Silicon según modelo y cuantización.
Crear scripts reproducibles para arrancar modelos con configuración estable.
Integrar llama-server con aplicaciones Python, clientes OpenAI compatibles o frontends internos.
Registrar logs, métricas básicas y errores de inferencia.
Evitar exponer llama-server sin autenticación, proxy o aislamiento adecuado.
Realizar ejercicio de serving local con llama.cpp y consumo desde una API propia.

Tema 8: vLLM y serving de alto rendimiento

Comprender cuándo vLLM aporta valor frente a Ollama o llama.cpp.
Desplegar un modelo con servidor compatible con OpenAI API.
Configurar batch, streaming, paralelismo, uso de GPU, contexto, API key y parámetros del servidor.
Evaluar throughput, latencia, concurrencia y coste por usuario interno.
Usar vLLM para escenarios multiusuario, APIs internas, prototipos de producción y cargas mayores.
Revisar soporte de modelos Hugging Face, tool calling, structured outputs y multimodalidad según modelo.
Controlar logs de prompts y outputs para evitar fugas de datos sensibles.
Integrar vLLM con balanceadores, Docker, Kubernetes y API gateways.
Comparar rendimiento de vLLM, Ollama y llama.cpp con el mismo caso de uso.
Realizar ejercicio de despliegue de vLLM y consumo desde una aplicación RAG.

Tema 9: LM Studio, Open WebUI y herramientas de usuario final

Usar LM Studio como laboratorio local para probar modelos, parámetros y APIs locales.
Desplegar Open WebUI u otras interfaces para facilitar pruebas con usuarios internos.
Crear perfiles de modelos, conversaciones, system prompts y conexiones a servidores locales.
Evaluar qué herramientas sirven para prototipado y cuáles requieren gobierno antes de producción.
Gestionar usuarios, permisos, logs, historial, modelos disponibles y exposición de datos.
Crear entorno de pruebas para negocio sin dar acceso directo a infraestructura crítica.
Comparar experiencia de usuario entre interfaz web, API interna, chatbot corporativo y aplicación integrada.
Evitar que las interfaces de laboratorio se conviertan en soluciones productivas sin controles.
Preparar guía de uso para equipos no técnicos en entornos seguros.
Realizar ejercicio de publicación controlada de un asistente local para pruebas internas.

Tema 10: Embeddings: significado, modelos y estrategia

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.
Gestionar versiones de embeddings y reindexado cuando cambia el modelo.
Evitar mezclar embeddings de modelos distintos dentro de la misma colección sin estrategia.
Realizar ejercicio de comparación de embeddings sobre un corpus documental realista.

Tema 11: Bases de datos vectoriales: conceptos y criterios de elecció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.
Decidir según escala, persistencia, filtros, búsqueda híbrida, HA, cloud, on-premise, backups y observabilidad.
Entender HNSW, IVF, PQ, quantization, payload indexes y trade-offs entre precisión, memoria y velocidad.
Diseñar colecciones por dominio, cliente, departamento, sensibilidad o caso de uso.
Usar metadata para permisos, fecha, fuente, versión, idioma, tipo documental y owner.
Evitar guardar solo vectores sin trazabilidad hacia documento, fragmento y versión original.
Crear matriz de decisión para elegir base vectorial según escenario corporativo.
Realizar ejercicio de diseño de arquitectura vectorial para tres niveles de escala.

Tema 12: Chroma para prototipos, local-first y búsquedas rápidas

Instalar Chroma en entorno local y crear una primera colección.
Insertar documentos, embeddings, metadatos e identificadores estables.
Consultar por texto, embedding, filtros y metadatos.
Usar Chroma para prototipos RAG, asistentes internos pequeños y validaciones rápidas.
Gestionar persistencia local y estructura de almacenamiento.
Diseñar colecciones separadas por caso de uso, modelo de embeddings o dataset.
Integrar Chroma con LangChain, LlamaIndex o código Python propio.
Evaluar límites de escalado, concurrencia, operación y gobierno frente a otras soluciones.
Evitar prototipos Chroma sin control de versiones de datos, embeddings y fuentes.
Realizar ejercicio de RAG local con Chroma y LLM servido en local.

Tema 13: Qdrant para búsqueda vectorial con filtros y producción

Desplegar Qdrant localmente con Docker o servicio interno.
Crear colecciones con vectores densos, sparse vectors y payload estructurado.
Configurar distancia, tamaño vectorial, HNSW, payload indexes y parámetros de búsqueda.
Usar filtros por metadata: departamento, permisos, fecha, tipo documental, cliente o confidencialidad.
Implementar búsqueda híbrida combinando similitud semántica y señales keyword/sparse.
Gestionar upserts, deletes, snapshots, backups y migraciones de colecciones.
Integrar Qdrant con APIs Python, frameworks RAG y servicios internos.
Medir latencia, recall, precisión y coste de consultas con filtros.
Evitar colecciones sin payload indexes cuando los filtros son críticos.
Realizar ejercicio de RAG con Qdrant, permisos por documento y búsqueda híbrida.

Tema 14: Milvus para escala, arquitectura distribuida y grandes volúmenes

Comprender cuándo Milvus aporta valor frente a soluciones locales más simples.
Desplegar Milvus standalone para laboratorio y revisar arquitectura distribuida para producción.
Crear colecciones, campos vectoriales, scalar fields, índices y particiones.
Implementar búsqueda densa, búsqueda sparse y búsqueda híbrida según el caso.
Gestionar grandes volúmenes de documentos, inserciones, particiones y consultas concurrentes.
Diseñar estrategia de particionado por tenant, dominio, fecha, sensibilidad o producto.
Integrar Milvus con pipelines de embeddings, RAG y servicios de backend.
Revisar mantenimiento, backups, upgrades, monitorización y costes operativos.
Evitar introducir Milvus en proyectos pequeños donde añade complejidad innecesaria.
Realizar ejercicio de diseño de RAG escalable con Milvus y búsqueda híbrida.

Tema 15: FAISS, pgvector y alternativas integradas

Usar FAISS como librería eficiente para búsqueda de similitud en memoria o almacenamiento local.
Diferenciar índices planos, IVF, HNSW, PQ y opciones con GPU cuando el volumen lo requiere.
Integrar FAISS en prototipos, notebooks, pipelines batch o servicios internos 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 FAISS, pgvector y bases vectoriales dedicadas en operación, escala y mantenimiento.
Evaluar Elasticsearch/OpenSearch cuando se necesita búsqueda híbrida integrada con texto empresarial.
Evitar usar FAISS como base productiva sin resolver persistencia, backups, concurrencia y actualización.
Diseñar estrategia de migración desde prototipo FAISS a base vectorial productiva.
Realizar ejercicio comparativo entre FAISS, pgvector y Qdrant para el mismo corpus.

Tema 16: Ingesta documental para RAG

Diseñar pipeline de ingesta desde PDF, DOCX, HTML, Markdown, TXT, CSV, Excel, correos y wikis internas.
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.
Evitar ingestar documentación obsoleta, contradictoria o no autorizada.
Crear logs de ingesta con errores, documentos procesados, descartes y avisos.
Realizar ejercicio de ingesta de repositorio documental corporativo anonimizado.

Tema 17: Chunking, segmentación y estructura de conocimiento

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 y código de forma diferenciada.
Añadir metadata contextual para mejorar filtros, trazabilidad y respuestas.
Evaluar chunking con métricas de recuperación y pruebas reales de usuario.
Evitar chunks gigantes que saturan contexto o chunks pequeños que pierden significado.
Realizar ejercicio de comparación de estrategias de chunking sobre documentación compleja.

Tema 18: Retrieval, filtros, búsqueda híbrida y reranking

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.
Evaluar rerankers locales y remotos según coste, latencia, idioma y calidad.
Diseñar estrategias multi-stage: retrieve amplio, filtrar, rerankear, comprimir y generar.
Medir recall, precision, MRR, nDCG y métricas prácticas de recuperación.
Evitar respuestas pobres causadas por recuperar contexto irrelevante o incompleto.
Crear fallback cuando no hay documentos relevantes suficientes.
Realizar ejercicio de mejora de retrieval con filtros, búsqueda híbrida y reranking.

Tema 19: Diseño de prompts para RAG y control de alucinaciones

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.
Gestionar contexto recuperado excesivo mediante compresión, selección o resúmenes previos.
Evitar prompts que animan al modelo a completar huecos con conocimiento general no autorizado.
Diseñar respuestas adaptadas a usuario final, técnico, legal, soporte o dirección.
Probar el prompt con preguntas con respuesta, sin respuesta, ambiguas y maliciosas.
Realizar ejercicio de prompt RAG con groundedness y formato de respuesta controlado.

Tema 20: Arquitecturas RAG avanzadas

Diferenciar naive RAG, advanced RAG, agentic RAG, GraphRAG, multi-hop RAG y corrective RAG.
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.
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.
Evitar arquitecturas excesivamente complejas antes de medir el problema real.
Realizar ejercicio de diseño de RAG avanzado para documentación técnica y normativa.

Tema 21: LangChain, LlamaIndex y frameworks de integración

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 estos frameworks.
Integrar Chroma, Qdrant, Milvus, FAISS o pgvector como vector stores.
Controlar abstracciones para no perder visibilidad sobre retrieval, prompts, latencia y errores.
Diseñar capas propias para evitar dependencia excesiva de un framework concreto.
Instrumentar pipelines para trazabilidad y evaluación.
Evitar copiar ejemplos de documentación sin adaptarlos a seguridad, permisos y datos reales.
Realizar ejercicio de implementación RAG con framework y versión equivalente sin framework.

Tema 22: APIs internas y aplicaciones empresariales con LLM local

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.
Usar clientes compatibles con OpenAI para abstraer el proveedor local.
Gestionar autenticación, autorización, sesiones, permisos y límites por usuario.
Crear streaming de respuestas para mejorar experiencia de usuario.
Añadir citación de fuentes, evidencias y documentos recuperados.
Preparar frontend simple para usuarios de negocio o integración con intranet.
Integrar con Teams, Slack, portales internos, Jira, Confluence, SharePoint o DMS cuando procede.
Evitar exponer directamente la base vectorial o el servidor LLM a usuarios finales.
Realizar ejercicio de API RAG con autenticación, streaming y fuentes citadas.

Tema 23: Seguridad, privacidad y aislamiento de datos

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 o entorno.
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 y trazas.
Realizar ejercicio de RAG con permisos por documento y pruebas de fuga de información.

Tema 24: Evaluación de RAG, LLMs locales y calidad de respuestas

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 y utilidad.
Comparar modelos locales, prompts, chunking, embeddings, top_k y rerankers con evidencias.
Usar herramientas como Ragas, TruLens, DeepEval, PromptTest, Phoenix o equivalentes.
Incorporar revisión humana en preguntas críticas o de alto impacto.
Crear quality gates antes de desplegar cambios de modelo, prompt o índice.
Realizar ejercicio de evaluación completa de una solución RAG local.

Tema 25: Observabilidad, logs y monitorización LLMOps

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.
Usar OpenTelemetry, Prometheus, Grafana, Phoenix, LangSmith, TruLens u opciones equivalentes.
Evitar logs con datos sensibles si no son necesarios para depuración.
Crear dashboards para operación técnica y reporting ejecutivo.
Preparar alertas por latencia, errores, caída del servidor LLM o baja calidad.
Realizar ejercicio de instrumentación y dashboard básico de una app RAG.

Tema 26: Rendimiento, escalabilidad y optimización

Medir throughput, latencia, tokens por segundo, concurrencia, memoria y uso de GPU.
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 y backpressure.
Separar servicios: ingesta, embeddings, base vectorial, LLM serving, API y frontend.
Escalar vertical u horizontalmente según cuello de botella real.
Evitar optimizaciones prematuras sin métricas.
Realizar ejercicio de optimización de un sistema RAG lento.

Tema 27: Contenedores, Docker y despliegue local/on-premise

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 y puertos.
Desplegar Qdrant, Milvus, PostgreSQL+pgvector o Chroma en entorno controlado.
Separar entornos dev, staging y producción.
Crear healthchecks, restart policies, backups y procedimientos de actualización.
Evitar contenedores con modelos enormes sin estrategia de almacenamiento y arranque.
Documentar despliegue reproducible para equipos de sistemas.
Realizar ejercicio de stack RAG completo con Docker Compose.

Tema 28: Kubernetes, GPU serving y operación corporativa

Diseñar despliegue en Kubernetes para LLM serving, API, vector DB, workers y frontends.
Configurar nodos GPU, device plugins, tolerations, affinity y límites de recursos.
Gestionar modelos en volúmenes, object storage, registries o sistemas compartidos.
Exponer servicios mediante ingress, API gateway, autenticación corporativa y TLS.
Escalar componentes según carga: serving, retrieval, ingesta, API y jobs de embeddings.
Gestionar actualizaciones blue/green o canary para modelos, prompts e índices.
Monitorizar GPU, CPU, RAM, VRAM, latencia, errores y saturación.
Diseñar alta disponibilidad para bases vectoriales y servicios críticos.
Evitar desplegar modelos locales en Kubernetes sin plan de coste, seguridad y mantenimiento.
Realizar ejercicio de arquitectura Kubernetes para RAG corporativo con GPU.

Tema 29: Integración con documentos corporativos y fuentes reales

Conectar SharePoint, Google Drive, Confluence, Jira, GitHub, GitLab, S3, DMS o file shares.
Diseñar conectores de ingesta con permisos, incrementalidad, extracción de metadatos y control de errores.
Respetar ACLs, grupos, propietarios, clasificación y herencia de permisos del origen.
Gestionar documentos borrados, movidos, renombrados, duplicados y obsoletos.
Normalizar contenido procedente de HTML, PDF, Markdown, tickets, issues, wikis y repositorios.
Crear estrategia de reindexado por cambios, frecuencia, criticidad y tamaño de corpus.
Evitar conectar fuentes sin owner, sin limpieza documental o sin política de permisos.
Generar informes de ingesta con errores, documentos omitidos y cobertura.
Diseñar mapa de fuentes para priorizar alto valor y bajo riesgo.
Realizar ejercicio de ingesta desde una wiki/documentación simulada con permisos.

Tema 30: Agentes locales, herramientas y RAG accionable

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.
Diseñar permisos por herramienta, usuario, documento y acción.
Evitar agentes que modifican sistemas internos sin trazabilidad ni validación.
Usar MCP u otros patrones de tool access cuando el proyecto lo requiere.
Registrar tool calls, argumentos, resultados, errores y decisiones del agente.
Evaluar calidad de agentes por éxito de tarea, seguridad, coste, latencia y necesidad de intervención.
Realizar ejercicio de agente local que consulta documentos y ejecuta una acción aprobada.

Tema 31: RAG multimodal y documentos complejos

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.
Tratar documentos largos con jerarquía, resúmenes por sección y recuperación contextual.
Diseñar respuestas que indiquen si una conclusión procede de texto, tabla, imagen o metadato.
Evitar que el sistema ignore información visual crítica en manuales, planos o informes técnicos.
Evaluar calidad de extracción antes de indexar.
Preparar estrategia para documentos escaneados, contratos, manuales, fichas técnicas y presentaciones.
Realizar ejercicio de RAG sobre PDF técnico con tablas e imágenes.

Tema 32: Casos de uso por departamento

Diseñar RAG para soporte IT con runbooks, FAQs, tickets históricos y documentación interna.
Diseñar RAG para legal con contratos, políticas, DPAs, consultas, playbooks y confidencialidad estricta.
Diseñar RAG para RRHH con políticas, onboarding, formación, procedimientos y consultas repetitivas.
Diseñar RAG para ventas con fichas de producto, propuestas, objeciones, casos de éxito y precios aprobados.
Diseñar RAG para ingeniería con documentación técnica, código, APIs, arquitectura y decisiones.
Diseñar RAG para operaciones con procedimientos, calidad, mantenimiento, incidencias y manuales.
Diseñar RAG para finanzas con políticas, reporting, cierres, controles y documentación interna.
Diseñar RAG para compliance con normativa, evidencias, controles, auditorías y políticas.
Priorizar casos por valor, riesgo, calidad documental, facilidad de ingesta y sponsor.
Realizar ejercicio de selección de tres casos de uso con roadmap de implantación.

Tema 33: Gobierno, modelo operativo y mantenimiento

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 y cobertura documental.
Gestionar versiones de modelos, embeddings, prompts, pipelines e índices.
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 e índices sin mantenimiento.
Realizar ejercicio de diseño de modelo operativo para IA local corporativa.

Tema 34: Troubleshooting y errores habituales en LLMs locales y RAG

Diagnosticar respuestas malas por modelo insuficiente, prompt débil, retrieval pobre o documentos mal procesados.
Detectar problemas de embeddings incompatibles, dimensiones incorrectas o colecciones mezcladas.
Resolver errores de contexto demasiado largo, truncamiento, respuestas incompletas o formato roto.
Investigar latencia alta por modelo, reranker, top_k, base vectorial o hardware.
Corregir alucinaciones causadas por contexto irrelevante o instrucciones contradictorias.
Revisar fallos de permisos cuando aparecen fuentes que el usuario no debería ver.
Diagnosticar OOM, falta de VRAM, modelos no cargan, drivers, CUDA, Metal o problemas de contenedor.
Preparar runbooks para Ollama, llama.cpp, vLLM, Qdrant, Milvus, Chroma y API propia.
Crear checklist de depuración antes de culpar al modelo.
Realizar ejercicio de reparación de un sistema RAG con fallos provocados.

Tema 35: Proyecto Final

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, 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, 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 y errores.
Evaluar calidad con dataset de preguntas, respuestas esperadas, groundedness, relevance y revisión humana.
Comparar al menos dos modelos locales, dos estrategias de chunking o dos bases vectoriales.
Optimizar rendimiento, memoria, latencia, top_k, prompt, contexto 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.

Preguntas frecuentes

Resolvemos todas tus dudas sobre nuestra formación en LLMs Locales, RAG y Bases de Datos Vectoriales

Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.

Es un modelo de lenguaje que se ejecuta en infraestructura propia o controlada, como un ordenador, servidor, workstation, entorno on-premise o nube privada.

¿Tienes dudas?
Estamos aqui para ayudarte

Contactar

Es un modelo de lenguaje que se ejecuta en infraestructura propia o controlada, como un ordenador, servidor, workstation, entorno on-premise o nube privada.

¿Tienes dudas?
Estamos aqui para ayudarte

Contactar

Curso de LLMs Locales, RAG y Bases de Datos Vectoriales

Aprende con el curso de LLMs Locales, RAG y Bases de Datos Vectoriales para empresas hasta 100% bonificado, a medida para tu organización.

¿Qué es FUNDAE?

¿Cómo funciona FUNDAE?

¿Cómo se bonifica un curso?

¿Qué es FUNDAE?

¿Cómo funciona FUNDAE?

¿Cómo se bonifica un curso?

¿Qué es FUNDAE?

¿Cómo funciona FUNDAE?

¿Cómo se bonifica un curso?