• Comprender el modelo, sus límites y sus costos. 
• Qué es un modelo de lenguaje. 
• Capacidades y limitaciones. 
• Tokens y ventana de contexto. 
• Generación probabilística. 
• Temperatura y parámetros principales. 
• Diferencia entre generación, embeddings y reranking. 
• Modelos propietarios y modelos abiertos. 
• Costo, latencia y privacidad. 
• Criterios de selección de modelos. 
• Presentación del proyecto transversal. 
• Evolución desde RNN hasta Transformers. 
• Intuición del mecanismo de self-attention. 
• Tokenización BPE. 
• Lecturas introductorias. 
• Comparación entre modelos. 
• Elaboración de una matriz de selección.

Del modelo a una aplicación de software.

• Gestión Configuración del entorno. 
• Gestión de dependencias. 
• Variables de entorno y credenciales.
• Consumo de APIs. 
• Mensajes de sistema y usuario. 
• Zero-shot y few-shot prompting.
• Delimitación de instrucciones y contexto.
• Parámetros de generación. 
• Manejo básico de errores. 
• Configuración del repositorio. 
• Ejercicios de prompting. 
• Lectura de documentación. 
• Comparación entre llamadas síncronas y asíncronas. 
• Laboratorio: construcción de un cliente básico para consumir un modelo mediante API.

• Generar resultados utilizables por otros sistemas. 
• Structured outputs. 
• JSON Schema. 
• Validación con Pydantic. 
• Manejo de respuestas inválidas. 
• Tool calling. 
• Timeouts. 
• Reintentos. 
• Rate limits. 
• Registro de tokens. 
• Estimación de costos. 
• Medición de latencia. 
• Streaming. 
• Backoff. 
• Abstracción de proveedores. 
• Ejecución opcional con Ollama. 
• Finalización del primer entregable.
• Laboratorio: construcción de un servicio que transforme entradas no estructuradas en objetos validados.

• Preparación de información para recuperación semántica. 
• Información estructurada y no estructurada. 
• Embeddings. 
• Similitud semántica. 
• Limpieza y normalización. 
• Estrategias de chunking. 
• Solapamiento. 
• Metadata. 
• Identificadores y trazabilidad. 
• Separación entre ingesta y consulta. 
• Pruebas con distintos tamaños de fragmento. 
• Comparación de estrategias de chunking. 
• Procesamiento del dataset del proyecto. 
• Chunking semántico como contenido complementario. 
• Laboratorio: construcción del pipeline inicial de ingesta documental. 

• Construcción del motor de búsqueda semántica. 
• Almacenamiento vectorial. 
• Similitud coseno. 
• Recuperación por vecinos cercanos. 
• Top-k. 
• Filtrado por metadata. 
• Persistencia del índice. 
• Selección de modelos de embeddings. 
• Diagnóstico de resultados irrelevantes. 
• Detección de resultados redundantes. 
• Comparación entre ChromaDB y FAISS. 
• Embeddings locales. 
• Evaluación manual de consultas. 
• Finalización del pipeline de recuperación.
• Laboratorio: implementación de un buscador semántico sobre el conjunto documental.

• Construcción de un sistema de generación sustentada. 
• Arquitectura Retrieval-Augmented Generation. 
• Flujo consulta-recuperación-contexto-generación. 
• Construcción explícita sin frameworks de alto nivel. 
• Diseño del prompt con evidencia recuperada. 
• Gestión de la ventana de contexto. 
• Separación entre instrucciones, evidencia y consulta. 
• Respuestas sustentadas. 
• Manejo de ausencia de evidencia. 
• Implementación de citas. 
• Registro de documentos utilizados. 
• Registro de fragmentos recuperados. 
• Pruebas sobre el dataset del proyecto. 
• Laboratorio: integración del recuperador con el modelo generativo. 

• Diagnóstico y mejora del pipeline. 
• Errores de ingesta. 
• Errores de recuperación. 
• Errores en la construcción del contexto. 
• Errores de generación. 
• Query rewriting. 
• Ajuste de top-k. 
• Redundancia de contexto. 
• Context compression. 
• Respuestas no sustentadas. 
• Estrategias de debugging. 
• Multi-query retrieval. 
• Recuperación jerárquica. 
• Preparación de casos de prueba. 
• Finalización del sistema RAG con fuentes.
• Laboratorio: análisis y corrección de casos fallidos del sistema RAG. 

• Medir antes de optimizar. 
• Evaluación de recuperación y generación. 
• Construcción de un dataset de evaluación. 
• Hit rate y recall. 
• Fidelidad. 
• Relevancia. 
• Evaluación humana. 
• LLM-as-a-Judge. 
• Comparación de versiones. 
• Medición de costo y latencia. 
• Análisis de errores. 
• RAGAS. 
• Precision@k y MRR. 
• BM25. 
• Búsqueda híbrida. 
• Reranking. 
• Aplicación de una mejora. 
• Informe comparativo antes y después. 
• Laboratorio: medición del sistema base y comparación de resultados.

• Automatización inteligente bajo control. 
• Diferencia entre chatbot, workflow y agente. 
• Casos en los que no conviene utilizar agentes. 
• Tool calling. 
• Diseño de herramientas. 
• Contratos de entrada y salida. 
• Validación de argumentos. 
• Estado de ejecución. 
• Rutas condicionales. 
• Límites de pasos. 
• Registro de decisiones.
  
• Reintentos. 
• Fallbacks. 
• Prevención de loops. 
• Idempotencia. 
• Registro de acciones. 
• Finalización de las herramientas del proyecto. 

• Orquestación e interoperabilidad. 
• Workflows con estado. 
• Nodos, transiciones y condiciones. 
• Manejo de errores. 
• Aprobación humana. 
• Acciones sensibles. 
• Introducción a Model Context Protocol. 
• Clientes, servidores, herramientas y recursos. 
• Consumo de una herramienta mediante MCP. 
• Comparación entre API directa, tool calling y MCP. 
• Creación mínima de un servidor MCP. 
• Integraciones adicionales. 
• Comparación con otros frameworks. 
• Finalización del workflow del proyecto. 
• Laboratorio: integración de una herramienta externa con aprobación humana. 

• Preparación de un prototipo reproducible e integrable. 
• Seguridad: prompt injection directa e indirecta, contenido recuperado no confiable, validación de entradas y salidas, autorización de herramientas, mínimo privilegio y gestión de credenciales. 
• Observabilidad: logging estructurado, trazas por ejecución, tokens y costos, latencia por etapa, errores, reintentos y herramientas invocadas.
• Despliegue: FastAPI, modelos de entrada y salida, manejo de errores HTTP, configuración por entorno, health checks y documentación automática. ● Docker. 
• Persistencia mínima. 
• Streamlit para demostraciones. 
• Checklist de seguridad. 
• Pruebas de ejecución local. 
• Documentación de la API. 
• Laboratorio: exposición de la solución mediante una API. 

• Validación técnica de la solución. 
• Integración de componentes. 
• Pruebas end-to-end. 
• Revisión de arquitectura. 
• Revisión del pipeline de evaluación. 
• Análisis de costos. 
• Identificación de riesgos. 
• Validación de resultados y cumplimiento de la consigna. 
• Revisión final de criterios técnicos y de entrega. 
• Retroalimentación docente. 
• Finalización del repositorio. 
• Documentación. 
• Preparación de métricas. 
• Diagrama de arquitectura. 
• Preparación de la entrega final. 
• Envío individual del Trabajo Práctico Final. 

Ingeniero Electrónico (ITBA) desarrollando tareas en el área de procesamiento de señales y machine learning en el Grupo de Electrónica Digital Aplicada (GEDA). Profesor adjunto de materias en el área de procesamiento de señales, bio-electrónica y sistemas digitales. Entre ellas Redes Neuronales y Redes Neuronales en Bioingeniería.