Cinco repos que valen más que el curso de IA

01 el problema

Lo que compras cuando compras un curso

Un curso de inteligencia artificial de los que se anuncian ahora cuesta entre varios cientos y varios miles de euros. Y conviene separar bien qué te está vendiendo, porque no es lo que parece.

Lo que de verdad compras son tres cosas, y solo una de ellas es cara de conseguir por tu cuenta:

• El orden. Qué se aprende antes que qué. Esto sí tiene valor, y es

exactamente lo que trae esta guía en el apartado del montaje.

• El compromiso. Haber pagado te hace terminarlo. Es psicología, no

formación, pero funciona y sería deshonesto no decirlo.

• El contenido. Que casi siempre es documentación oficial reordenada y

grabada en vídeo. Esto es lo que no hace falta comprar.

La prueba honesta

Coge el temario del curso que estabas a punto de pagar. Cuenta cuántos módulos son «introducción a», «qué es» y «panorama general». Ésos son los que esta guía sustituye entera. Los que hablen de un caso concreto de tu sector, ésos no.

02 el método

El orden, que importa más que la lista

La mayoría de las listas empiezan por la librería más famosa y te dejan escribiendo cableado antes de haber visto funcionar nada. Aquí el orden es al revés: primero ves cosas funcionando, y el cableado va al final, cuando ya sabes qué estás cableando.

Tiempo total

una tarde, unas cuatro horas con descansos

Coste

cero euros, y sin tarjeta en ningún paso

Requisitos

una terminal y espacio en disco

Al terminar

cinco cosas corriendo en tu ordenador

• Un ordenador con terminal: Mac, Linux, o Windows con WSL
• Python entre 3.10 y 3.13. No 3.14: CrewAI todavía no instala ahí (comprobado en PyPI el 31/08/2026)
• Git
• Unos 20 GB libres en disco: los modelos ocupan
• Cuatro horas de tarde sin reuniones

03 el catálogo

Repo 1 · Awesome LLM Apps

Se empieza aquí por un motivo: es el único de los cinco que te enseña cosas terminadas. Los otros cuatro son piezas; éste es el catálogo de lo que se puede construir con ellas.

Dentro hay más de cien aplicaciones de ejemplo, cada una con su código completo y su explicación: agentes que investigan, que resumen, que hacen preguntas sobre documentos, que se coordinan entre varios.

git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git && cd awesome-llm-apps

Qué hacer con él el primer día

No leerlo entero. Abre el listado, elige una aplicación que se parezca a algo que tú harías, y clónala sola. El objetivo de la primera hora no es entender: es ver algo funcionando en tu pantalla.

La trampa del catálogo

Un repo con cien ejemplos es una invitación a pasarse la tarde mirando y no montar ninguno. Ponte un límite: una aplicación, funcionando, antes de pasar al repo 2. Si no arranca en veinte minutos, elige otra; algunos ejemplos dependen de servicios externos y no todos están igual de cuidados.

04 el motor

Repo 2 · Ollama

Aquí es donde esto deja de costar dinero. Ollama descarga un modelo de lenguaje y lo ejecuta en tu máquina: sin suscripción, sin clave de pago y sin que nadie te cuente los mensajes.

curl -fsSL https://ollama.com/install.sh | sh

Y con eso, un modelo corriendo:

ollama run llama3.2

La primera vez descarga el modelo y tarda; después arranca en segundos. Verás una barra de progreso con el tamaño, un par de líneas de verificación y al final un >>> esperando a que escribas.

El tamaño depende del modelo que pidas, no del comando. llama3.2 a secas es el de 3.000 millones de parámetros y ronda los 2 GB; los de 7B u 8B se van a 4 o 5 GB. Si ves un número que no esperabas, mira qué etiqueta has pedido: es la confusión más común y la que hace que alguien con 8 GB de RAM se baje un modelo que no le va a girar.

Cómo elegir el modelo

Ésta es la parte donde la gente pierde una hora. La regla corta:

Si tienes gráfica dedicada, la tabla cambia: manda la VRAM, no la RAM. Un equipo con 32 GB de sistema y una gráfica de 8 GB se comporta como uno de 8, no como uno de 32, porque el modelo se carga en la tarjeta. Mira la memoria de la gráfica y busca esa fila.

No empieces por el modelo más grande que te quepa. Vas a esperar treinta segundos por respuesta y vas a abandonar el ejercicio. Para aprender, la velocidad importa más que la calidad.

Conectar el ejemplo del repo 1 a Ollama

Ahora vuelve a la aplicación que clonaste y cámbiale el proveedor. Casi todas llevan una variable de entorno o una línea de configuración:

Tengo esta aplicación de ejemplo clonada y está configurada para usar un
proveedor de pago. Quiero apuntarla a un modelo local que corre con Ollama en
http://localhost:11434.

Haz esto:

1. Busca en el proyecto dónde se configura el proveedor del modelo y
   enséñame el archivo y la línea, sin cambiar nada todavía.
2. Dime qué hay que cambiar exactamente y qué riesgo tiene.
3. Si hace falta instalar algo, dime qué y por qué.

Después de que te lo apruebe, haz el cambio y ejecuta la aplicación. Si falla,
enséñame el error entero antes de intentar arreglarlo.

La última línea es la importante. Sin ella empieza a probar arreglos a ciegas y acabas con cuatro cambios que no sabes cuál era el bueno.

05 tus datos

Repo 3 · el RAG sobre tus documentos

Le tiras encima tus PDFs, tus notas y las facturas del año, preguntas en cristiano y te responde con lo que hay dentro. Eso se llama RAG, y al terminar este apartado ya sabrás hacerlo sin haber pagado un euro.

Cuál elegir, que depende de quién lo ejecuta

Aquí no hay una respuesta única y las guías que dan una sola sospechan poco:

Para esta tarde, AnythingLLM. RAGFlow es mejor motor de lectura, pero levantarlo son varios contenedores y el objetivo de hoy es aprender el concepto, no administrar servicios.

Las dos perillas que deciden si contesta bien

Un RAG no lee tus documentos enteros: los trocea, convierte cada trozo en números con un modelo de embeddings, y cuando preguntas recupera los trozos más parecidos y solo esos van al modelo de lenguaje.

Lo digo porque es la causa número uno de que un RAG local conteste mal, y casi nadie la mira: si los trozos son demasiado pequeños, la respuesta queda partida por la mitad y nunca se recupera entera; si son enormes, entra ruido y el modelo se pierde. Y el que decide qué se recupera es el modelo de embeddings, no el de lenguaje. Cuando algo salga mal la culpa parece del modelo grande y casi siempre está en estas dos perillas. AnythingLLM trae valores por defecto que sirven para empezar; si algo no se encuentra, es lo primero que se toca.

Qué preguntar para saber si funciona

No preguntes «resume esto». Eso lo hace cualquier cosa. Pregunta algo que solo se pueda contestar leyendo tus documentos:

1. ¿En qué documento aparece [un dato concreto que sabes que está] y en qué
   parte?

2. ¿Hay algo que se contradiga entre dos documentos? Si lo hay, dime cuáles y
   qué dice cada uno.

3. ¿Qué NO está cubierto en estos documentos sobre [tema]? Si no puedes
   saberlo, dilo en vez de inventarlo.

La tercera es la que separa un RAG que sirve de uno que te va a meter en un lío. Si contesta con seguridad a lo que no está, no lo uses para nada que importe.

06 el equipo

Repo 4 · CrewAI

Cuando un modelo solo se atasca con algo grande, CrewAI le monta un equipo alrededor. Se reparten el encargo, se corrigen entre ellos y no vuelven a molestarte hasta que está terminado. Tú pulsas enter y te vas a por café.

pip install crewai

El ejemplo mínimo que enseña el concepto

from crewai import Agent, Task, Crew, LLM

# Apunta al modelo que ya tienes girando con Ollama: cero coste por llamada.
modelo = LLM(model="ollama/llama3.2", base_url="http://localhost:11434")

investigador = Agent(
    role="Investigador",
    goal="Reunir los hechos comprobables sobre el tema que se te dé",
    backstory=(
        "Eres escéptico. No das por bueno un dato sin poder decir de dónde "
        "sale. Cuando no sabes algo, escribes que no lo sabes."
    ),
    llm=modelo,
)

redactor = Agent(
    role="Redactor",
    goal="Escribir un resumen corto y honesto con lo que te pase el investigador",
    backstory=(
        "Escribes en español llano, frases cortas y sin adjetivos de relleno. "
        "Si el material que recibes es flojo, lo dices en vez de adornarlo."
    ),
    llm=modelo,
)

reunir = Task(
    description="Reúne los hechos sobre: {tema}",
    expected_output="Una lista de hechos, cada uno con su matiz de confianza",
    agent=investigador,
)

escribir = Task(
    description="Escribe un resumen de 200 palabras con esos hechos",
    expected_output="Un texto de 200 palabras, sin viñetas",
    agent=redactor,
)

equipo = Crew(agents=[investigador, redactor], tasks=[reunir, escribir])
print(equipo.kickoff(inputs={"tema": "el coste real de automatizar un proceso"}))

Lo que se aprende aquí y no en un vídeo

Que el backstory importa más que el goal. El objetivo dice qué hacer; la historia dice cómo se comporta cuando algo no encaja, que es donde se decide si el resultado sirve. Cambia las dos historias del ejemplo y vuelve a ejecutarlo: vas a ver la diferencia inmediatamente.

Y una segunda cosa, menos agradable: un equipo de agentes se equivoca más veces que uno solo, porque cada paso hereda los errores del anterior. Sirve cuando la tarea es genuinamente larga; para algo corto, es maquinaria de más.

07 el cableado

Repo 5 · LangChain

Falta la pieza que en realidad te van a pedir en una entrevista. LangChain es el cableado: une el modelo con tus datos, con tus herramientas y con lo que ya tienes montado, y decide qué se llama y en qué orden.

Sin eso tienes cinco juguetes sueltos; con eso tienes un sistema.

pip install langchain langchain-ollama

Por qué va el último y no el primero

Porque hasta ahora has visto qué hace cada pieza. LangChain no hace nada por sí mismo: organiza lo que hacen las demás. Aprenderlo antes de haber visto las piezas es aprender un organizador de cosas que no conoces, y es exactamente el motivo de que tanta gente lo encuentre confuso.

from langchain_ollama import OllamaLLM
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

modelo = OllamaLLM(model="llama3.2")

plantilla = ChatPromptTemplate.from_template(
    "Eres un analista de procesos. Te doy una descripción de una tarea "
    "repetitiva y me devuelves TRES cosas, en este orden y sin adornos:\n"
    "1. Cuántas veces al mes se hace, si se puede deducir del texto.\n"
    "2. Qué parte se arregla ordenando lo que ya hay, sin automatizar.\n"
    "3. Qué parte necesitaría automatización de verdad, y por qué.\n\n"
    "Si algo no se puede deducir del texto, dilo. No lo inventes.\n\n"
    "Tarea: {tarea}"
)

cadena = plantilla | modelo | StrOutputParser()

print(cadena.invoke({
    "tarea": "Cada lunes copio los albaranes del correo a una hoja de cálculo"
}))

Esas tres barras verticales son lo que hay que entender de LangChain. Es una tubería: la plantilla produce un texto, el modelo lo consume y produce otro, y el analizador lo convierte en algo con lo que se puede seguir trabajando. Todo lo demás del framework es esa idea repetida con piezas más grandes.

Cómo saber si de verdad hace falta

Pregunta honesta: si tu proyecto son tres pasos fijos, escribirlos a mano en Python es más corto y más fácil de depurar. LangChain gana cuando los pasos cambian, se ramifican o hay que cambiar de proveedor sin reescribir todo.

Mira cualquier oferta de trabajo de esta semana y cuenta cuántas lo nombran. Ése es el otro motivo, y es legítimo.

08 el plan

La tarde entera, en orden

1. Primera hora · el catálogo

   Clona Awesome LLM Apps, elige UNA aplicación y ponla a funcionar como puedas. Si pide una clave de pago, déjala a medias y sigue: vuelves en la hora dos.

2. Segunda hora · el motor

   Instala Ollama, baja un modelo del tamaño que te pida tu equipo, y apunta la aplicación de la hora uno a ese modelo. Aquí es donde deja de costar dinero.

3. Descanso de verdad

   Veinte minutos fuera de la pantalla. Lo que viene requiere cabeza.

4. Tercera hora · tus documentos

   Monta AnythingLLM, mete diez documentos tuyos y hazle las tres preguntas de la prueba. Sobre todo la tercera.

5. Cuarta hora · el equipo y el cableado

   Instala CrewAI y ejecuta el ejemplo de dos agentes. Luego LangChain y la tubería de tres piezas. No intentes combinarlos hoy.

6. Al terminar · escribe qué has descartado

   Dos líneas por herramienta: para qué la usarías y para qué no. Esto es lo que vas a agradecer dentro de un mes, y es literalmente lo que monta la guía hermana de esta bitácora.

Si te atascas más de veinte minutos

Salta. En serio. El objetivo de la tarde es tener criterio sobre las cinco piezas, no tener las cinco perfectas. Una herramienta que no arranca hoy te enseña algo igualmente: que su instalación es frágil, y eso es un dato real para decidir si la usas en algo serio.

09 el balance

Qué sabes hacer al terminar, y qué no

Esto es lo que casi ninguna lista de repos escribe, y es la parte que evita que hagas el ridículo en una conversación técnica.

Lo que sí sabes hacer:

• Ejecutar un modelo de lenguaje en tu máquina y elegir el tamaño según el equipo.
• Montar RAG sobre documentos propios y —más importante— comprobar si miente.
• Orquestar varios agentes y explicar por qué el comportamiento se define en la

historia y no en el objetivo.

• Encadenar plantilla, modelo y analizador, y decir cuándo eso sobra.
• Leer el código de una aplicación con agentes y entender qué hace.

Lo que NO sabes hacer todavía, y conviene no fingirlo:

• Poner nada de esto en producción con usuarios reales. Eso son autenticación,

costes, límites de uso, registros y un plan para cuando falle.

• Evaluar la calidad con método. Has probado a mano; medir de verdad es otra

disciplina entera.

• Ajustar o entrenar un modelo. No has tocado eso ni de lejos.
• Estimar lo que cuesta a escala. Local es gratis; mil usuarios no.

10 lo que sale mal

Los cuatro errores caros

1 · Empezar por LangChain

Es el más famoso, así que es por donde empieza todo el mundo, y es un organizador de piezas que aún no conoces. Sales pensando que la IA es complicadísima cuando lo que era complicado era el orden.

2 · Bajar el modelo más grande que quepa

Treinta segundos por respuesta convierten el aprendizaje en una tortura. Para aprender, rápido gana a bueno.

3 · Meter documentos de clientes en el RAG de pruebas

Se indexan y se quedan. Prueba con material tuyo.

4 · Guardar la tarde en la cabeza

Cinco herramientas nuevas en cuatro horas se olvidan en una semana. Dos líneas por herramienta al terminar y el mes que viene sigues sabiendo por qué descartaste una.

11 honestidad

Y cuándo sí vale la pena pagar

Sería fácil terminar diciendo que nunca hace falta pagar. No es verdad.

• Cuando necesitas la fecha límite. Si sabes que sin un calendario y alguien

esperándote no lo terminas, el curso te está vendiendo disciplina y eso vale.

• Cuando es de tu sector concreto. «IA para despachos de abogados» con casos

reales de despachos no está en ningún repositorio.

• Cuando el que enseña es quien lo construyó. Pagas por su criterio y por

poder preguntarle, no por el temario.

Lo que no vale la pena es pagar por una introducción. Eso lo acabas de hacer tú solo, en una tarde y sin tarjeta.

12 el portafolio

El proyecto que sí puedes enseñar

Terminar la tarde con cinco herramientas instaladas no es un portafolio. Un portafolio es una cosa que funciona y que puedes enseñar en dos minutos.

Aquí va el proyecto que yo montaría con estas cinco piezas, porque usa cuatro de ellas, se entiende sin explicar nada y resuelve un problema que tiene todo el mundo: un lector de tus propios documentos que dice cuándo no sabe algo.

1. Los documentos

   Veinte o treinta archivos tuyos de un mismo asunto: apuntes, contratos, actas, facturas de un proveedor. Del mismo asunto, no mezclados: un RAG sobre material revuelto contesta mal y no sabrás si es culpa del montaje o del material.

2. El motor, en local

   Ollama con un modelo mediano. Cero coste por pregunta, y puedes enseñarlo sin que nadie te pregunte cuánto gastas.

3. La lectura

   AnythingLLM apuntado a ese modelo. Aquí ya tienes algo que funciona.

4. La pieza que lo hace tuyo

   No es código: es la pregunta con la que lo enseñas. Una que no esté en los documentos, para que se le vea decir «no está aquí».

Por qué el diferencial no es más código

Aquí es donde casi todas las guías —y la primera versión de ésta— te mandan escribir una cadena de LangChain «delante» de AnythingLLM para obligarle a citar la fuente. Te ahorro la tarde: AnythingLLM ya cita de serie. Y una cadena así no iría delante, iría *después* de recuperar los fragmentos, porque sin recuperador no tiene nada que citar.

Si lo montas por tu cuenta —cargador, troceado, embeddings, base vectorial, recuperador— entonces sí tiene sentido, y es un proyecto entero, no una tarde. Lo dejo dicho por si te apetece, pero no es lo que separa tu portafolio del de los demás.

Por qué esto impresiona y una demo de resumen no

Lo que lo separa es más barato y casi nadie lo hace: casi todo el mundo enseña el caso en que funciona. Enseñar el caso en que la herramienta dice «no lo sé» demuestra que has pensado en cuándo falla, y eso es lo que distingue a alguien que ha visto vídeos de alguien que ha montado cosas.

Cuando lo enseñes, haz esto: una pregunta que sí está en los documentos, y después una que no está. La segunda es la que cuenta. Si contesta «no está en los documentos» en vez de inventarse algo, tienes un proyecto que enseñar.

13 el resumen

Los cinco, uno al lado del otro

Las dos columnas de la derecha son las que valen. La de «qué es» la copia cualquiera; saber cuándo *no* usar una herramienta es lo que se aprende montándola.

Lo que comparten los cinco y conviene mirar

Los cinco son abiertos y los cinco están vivos —hay que comprobarlo, porque en este sector hay listas circulando llenas de proyectos parados—. Lo que yo miro antes de instalar nada:

• La fecha del último cambio. Si lleva más de seis meses quieto, cuidado.
• La licencia. MIT y Apache dejan hacer casi todo; hay populares con

licencias más exigentes que traen consecuencias si esto acaba en una empresa.

• Si hay issues abiertas recientes con respuesta. Un repositorio con

preguntas sin contestar desde hace meses es un repositorio en el que te vas a quedar solo.

14 dudas

Las preguntas que salen siempre

¿Esto sirve si no sé programar?

Los repos 1, 2 y 3 sí: se instalan con comandos que se copian y tienen interfaz. Los repos 4 y 5 son Python y ahí sí hace falta leer código, aunque sea poco. Haz los tres primeros igualmente: el criterio que sacas ya vale la tarde.

¿Un modelo en local es igual que uno de pago?

No, y quien te diga que sí te está vendiendo algo. Los de pago responden mejor en razonamiento largo. Los locales ganan en coste cero, sin cupo y sin que tus datos salgan de tu máquina, que para aprender y para material sensible es exactamente lo que quieres.

¿Cuánto ocupa todo esto?

El grueso son los modelos: entre 2 y 8 GB cada uno según tamaño. Lo demás es código y pesa poco. Con 20 GB libres vas sobrado para la tarde.

¿Puedo borrarlo todo después?

Sí, y conviene hacerlo con lo que no vayas a usar. Los modelos se quitan con ollama rm <nombre>, y los repos clonados son carpetas.

¿Cuál me quedo si solo puedo quedarme uno?

Ollama, sin dudarlo. Es el que cambia lo que puedes hacer sin pagar, y es el que usarás aunque acabes trabajando con modelos de pago: para probar cosas antes de gastar.

¿Y si mi ordenador es viejo?

Prueba con un modelo de 3B. Si tampoco, haz los repos 1 y 5 —el catálogo y el cableado— apuntando a un proveedor con capa gratuita. Pierdes lo de «sin tarjeta», pero el criterio se aprende igual.

15 el siguiente paso

Lo que viene después de la tarde

Terminada la tarde tienes criterio y cero rumbo. Las tres direcciones que tienen sentido, con lo que cuesta cada una:

La tercera es la que yo elegiría, y no por vender nada: porque las dos primeras te dejan sabiendo herramientas, y la tercera te deja sabiendo si alguna resuelve un problema que le importa a alguien. Que es una pregunta distinta.

Y hay una guía hermana en esta bitácora para justo eso: medir un proceso con un cronómetro y una hoja antes de decidir si se automatiza.

16 el dinero

Lo que de verdad cuesta, con la cuenta delante

Toda la tarde es gratis. Pero conviene saber dónde empieza a costar, porque es la pregunta que te van a hacer en cuanto enseñes algo de esto a alguien con presupuesto.

La tarde de hoy

0 €, y sin meter tarjeta en ningún paso

Lo que gastas

electricidad y unos 20 GB de disco

Donde empieza a costar

cuando lo usa alguien que no eres tú

Lo primero que se paga

casi nunca el modelo, casi siempre el sitio donde corre

Los tres momentos en que esto deja de ser gratis

Uno · cuando lo tiene que usar otra persona. Tu portátil no puede ser el servidor. Ahí aparece una máquina en algún sitio, y una máquina con memoria suficiente para un modelo no es la más barata del catálogo.

Dos · cuando la calidad local no llega. Para razonamiento largo o para idiomas menos frecuentes, los modelos grandes de pago siguen ganando. El patrón sensato es mezclar: local para lo repetitivo y de volumen, de pago para lo difícil.

Tres · cuando hay que responder rápido y a la vez. Un modelo local atiende una petición cómodamente. Diez a la vez ya no, y ahí entra infraestructura de verdad.

La comparación honesta

No hay un ganador. Quien te diga que lo local sustituye a lo de pago, o al revés, está simplificando. Lo que esta tarde te da es poder decidir cuál de las dos columnas te toca en cada caso, que es lo que no se aprende viendo vídeos.

El error de cálculo que ve todo el mundo

Comparar el precio de la suscripción con cero y concluir que local es más barato. Falta el tiempo. Montar, mantener y actualizar tiene un coste en horas, y si tus horas valen algo, en muchos casos la suscripción sale ganando.

Local gana claramente en dos supuestos: cuando los datos no pueden salir, y cuando el volumen es tan alto que la factura duele. Fuera de esos dos, la respuesta honesta suele ser que pagues y te dediques a otra cosa — que es exactamente el mismo criterio que aplico cuando alguien me pide automatizar algo que hace tres veces al mes.