Cómo construir un sistema RAG usando Claude: una IA que funciona con tus propios datos (Guía completa)

Pregúntale a Claude sobre tu empresa, tus notas o tus archivos, y no sabrá nada. Nunca los ha visto. Solo conoce lo que aprendió durante el entrenamiento, y tu información no formaba parte de eso.

Un sistema RAG soluciona esto. En lugar de responder de memoria, Claude primero busca en tus documentos, extrae las partes relevantes y responde basándose en lo que realmente encontró. Tus datos, su fuente, sin conjeturas.

Por qué es mejor que simplemente pegar archivos en el chat:

Escala. Toda tu base de conocimiento no cabe en un solo chat. RAG almacena todo y solo extrae lo que necesita cada pregunta.

Es más barato. Pegar un archivo hace que Claude relea el documento completo en cada pregunta. RAG lo lee una vez y luego obtiene solo la parte relevante. En lugar de enviar un manual de 10,000 tokens cada vez, podría enviar 500 tokens de la sección exacta que necesitas. Las configuraciones reales reducen el uso de tokens en un 80% o más.

Es más preciso. Dale a un modelo un muro de texto enorme y perderá detalles en el medio. Dale unos pocos fragmentos precisos y las respuestas serán más exactas.

Se mantiene actualizado. Actualiza tus archivos una vez y el sistema usará la versión nueva. Sin tener que volver a pegar.

Al final de esta guía, tendrás uno funcionando con tus propios archivos, paso a paso, sin necesidad de un doctorado.

Lo que necesitarás

Antes de tocar código, aquí tienes la lista completa. Buena noticia: esta versión solo necesita una clave API, y todo lo demás funciona gratis en tu propia máquina.

1. Python 3.9 o superior. Para comprobar si lo tienes, abre tu terminal (Terminal en Mac, Símbolo del sistema en Windows) y escribe python --version. Si ves algo como 3.11, estás listo. Si no, descárgalo de python.org y ejecuta el instalador. En Windows, marca la casilla "Add Python to PATH" durante la instalación, de lo contrario los comandos siguientes no funcionarán.

2. Una clave API de Claude, más un pequeño saldo de crédito. Esta es la única clave y el único dinero que necesita toda la guía. Aquí está la ruta exacta, clic a clic:

Ve a platform.claude.com, e inicia sesión (o regístrate) allí.

La API necesita un saldo positivo para funcionar, así que primero añade fondos. Cuando se te solicite, elige si los créditos son para ti o para una empresa, luego llegarás a la pantalla de pago. Elige la opción $5 "Starting out" (5 dólares "Empezando"). Es más que suficiente: todo lo demás en esta guía es gratuito y local, así que Claude es lo único que cuesta dinero, y cada pregunta te cuesta una fracción de centavo. Los créditos caducan un año después de la compra.

Después de pagar, llegarás a tu panel de Console. Deberías ver tu saldo (por ejemplo, $5.00) en la parte superior izquierda bajo "Organization credits".

Ahora obtén la clave. Haz clic en Get API key (Obtener clave API) (arriba a la derecha), luego en Create Key (Crear clave). Ponle cualquier nombre que te guste (por ejemplo, mi-clave-rag) y deja el espacio de trabajo como Default (Predeterminado). Haz clic en crear, luego copia la cadena que te muestra. Empieza con sk-ant- y solo la ves una vez, así que pégala en un lugar seguro por un momento.

Esa es toda la configuración.

Paso 1: Añade tu clave y carga tus archivos

1. Crea la carpeta del proyecto. Crea una nueva carpeta en tu escritorio y nómbrala rag-project. Todo irá aquí.

2. Abre tu terminal. En Mac: Cmd+Espacio, escribe Terminal, Enter. En Windows: Botón Inicio, escribe cmd, Enter.

3. Apunta la terminal a tu carpeta. Escribe cd y un espacio, luego arrastra la carpeta rag-project a la ventana de la terminal y presiona Enter. Todos los comandos siguientes se ejecutan desde dentro de esta carpeta.

1cd Desktop/rag-project

4. Instala las herramientas. Pega esto en tu terminal y presiona Enter (la primera ejecución puede tardar un minuto):

1pip install anthropic chromadb sentence-transformers pypdf python-dotenv

Si obtienes pip: command not found, usa pip3 en lugar de pip. Cuando la terminal muestre una línea nueva sin errores en rojo, ya está.

5. Crea tu archivo de código. Dentro de rag-project, crea un archivo vacío llamado exactamente rag.py. Ábrelo en cualquier editor de texto.

6. Crea tu archivo de clave. En la misma carpeta, crea un archivo llamado exactamente .env (comienza con un punto, sin nombre antes). Pega esto dentro, con la clave real que creaste durante la configuración después del =, sin espacios, sin comillas:

1ANTHROPIC_API_KEY=sk-ant-pega-tu-clave-real-aqui

Mantener la clave en .env en lugar de en tu código significa que no se filtrará si compartes el script o lo subes a GitHub.

7. Carga la clave. Pon esto al principio de rag.py:

1import os
2from dotenv import load_dotenv
3
4load_dotenv()  # lee tu archivo .env
5api_key = os.getenv("ANTHROPIC_API_KEY")

8. Crea tu base de conocimiento. Dentro de rag-project, crea una carpeta llamada documents. Coloca allí cualquier archivo .txt, .md o .pdf: tus notas, un documento de producto, resúmenes de reuniones, lo que sea.

8.1. Si aún no tienes archivos, usa este archivo de prueba. Crea notes.txt dentro de la carpeta documents y pega esto:

Project Northstar es nuestra herramienta interna para el seguimiento de comentarios de clientes. Se lanzó en marzo de 2026 y la mantiene el equipo de plataforma. La ingeniera principal es Dana Reyes. Los comentarios se revisan todos los viernes. Northstar reemplazó el antiguo sistema de hojas de cálculo que usábamos hasta 2025.

Al final, le preguntarás a Claude sobre Northstar y lo verás responder desde este mismo archivo.

9. Añade el código que lee tus archivos. Debajo del código del paso 7, en rag.py:

1from pathlib import Path
2from pypdf import PdfReader
3
4def load_documents(folder="documents"):
5    docs = []
6    for file in Path(folder).iterdir():
7        if file.suffix in [".txt", ".md"]:
8            text = file.read_text(encoding="utf-8")
9            docs.append({"source": file.name, "text": text})
10        elif file.suffix == ".pdf":
11            reader = PdfReader(str(file))
12            text = "\n".join(page.extract_text() or "" for page in reader.pages)
13            docs.append({"source": file.name, "text": text})
14    return docs
15
16documents = load_documents()
17print(f"Cargados {len(documents)} documento(s).")

10. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

Deberías ver:

Cargados 1 documento(s)

Si ves "Cargados 0 documento(s)", la carpeta documents está vacía o en el lugar incorrecto. Debe estar directamente dentro de rag-project, al lado de rag.py.

Paso 2: Divide tus archivos en fragmentos

Ahora mismo, cada archivo es un gran bloque de texto. Antes de poder buscar en él, debemos cortarlo en piezas más pequeñas llamadas fragmentos. He aquí por qué: cuando alguien hace una pregunta, el sistema encuentra los fragmentos que coinciden y envía solo esos a Claude. Si tus fragmentos son documentos enteros de 50 páginas, envías demasiado. Si son oraciones individuales, pierden contexto. Los párrafos pequeños son el punto óptimo.

1. Añade el código de división. Debajo del código del paso 10, en rag.py:

1def chunk_text(text, chunk_size=500, overlap=100):
2    words = text.split()
3    chunks = []
4    start = 0
5    while start < len(words):
6        end = start + chunk_size
7        chunk = " ".join(words[start:end])
8        chunks.append(chunk)
9        start = end - overlap  # retrocede un poco para que los fragmentos se superpongan
10    return chunks

Dos números que debes entender aquí, en términos simples:

• chunk_size=500 significa que cada fragmento tiene aproximadamente 500 palabras. Lo suficientemente grande para contener una idea completa, lo suficientemente pequeño para ser preciso.
• overlap=100 significa que cada fragmento repite las últimas 100 palabras del anterior. Esto es importante porque una respuesta podría estar justo en el límite donde se encuentran dos fragmentos. Sin superposición, una oración dividida por la mitad podría perderse. La superposición asegura que ninguna idea se escape.

2. Convierte cada documento en fragmentos. Añade esto debajo:

1all_chunks = []
2for doc in documents:
3    for chunk in chunk_text(doc["text"]):
4        all_chunks.append({"source": doc["source"], "text": chunk})
5
6print(f"Creados {len(all_chunks)} fragmento(s) a partir de {len(documents)} documento(s).")

Observa que cada fragmento lleva su source (el nombre del archivo del que proviene). Lo mantenemos adjunto durante todo el proceso, para que cuando Claude responda más tarde, pueda indicarte de qué archivo proviene la respuesta.

3. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

Deberías ver algo como:

Cargados 1 documento(s).

Creados 1 fragmento(s) a partir de 1 documento(s).

El archivo de prueba pequeño se convierte en un solo fragmento porque es corto. Los documentos reales producirán muchos. Si colocaste un PDF largo en la carpeta, podrías ver docenas o cientos de fragmentos, que es exactamente lo que quieres.

Paso 3: Convierte tus fragmentos en embeddings

Este es el paso que permite que la computadora busque por significado en lugar de palabras exactas. Cada fragmento se convierte en una lista de números (un embedding) que captura de qué trata. Los fragmentos con significado similar terminan con números similares. Más tarde, cuando llegue una pregunta, convertimos la pregunta en números también y encontramos las coincidencias más cercanas.

El modelo que hace esto se ejecuta localmente en tu máquina. Se descarga una vez, luego funciona sin conexión y es gratuito, y tus archivos nunca salen de tu computadora.

1. Carga el modelo de embeddings. Debajo del código del paso 2, en rag.py:

1from sentence_transformers import SentenceTransformer
2
3print("Cargando el modelo de embeddings (la primera ejecución lo descarga, unos 90 MB)...")
4embedder = SentenceTransformer("all-MiniLM-L6-v2")

La primera vez que ejecutes esto, descargará el modelo, así que dale un momento. Cada ejecución posterior es instantánea porque ya está en tu máquina.

2. Convierte cada fragmento en un embedding. Añade esto debajo:

1chunk_texts = [chunk["text"] for chunk in all_chunks]
2embeddings = embedder.encode(chunk_texts)
3
4print(f"Creados {len(embeddings)} embedding(s).")
5print(f"Cada embedding es una lista de {len(embeddings[0])} números.")

embedder.encode(...) toma tu lista de textos de fragmentos y devuelve un embedding por fragmento. Eso es todo.

3. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

La primera ejecución se detiene mientras se descarga el modelo, luego deberías ver algo como:

Cargados 1 documento(s).

Creados 1 fragmento(s) a partir de 1 documento(s).

Cargando el modelo de embeddings (la primera ejecución lo descarga, unos 90 MB)...

Creados 1 embedding(s).

Cada embedding es una lista de 384 números.

Esa línea de "384 números" es la idea completa hecha visible: tu texto ahora es una fila de números que la computadora puede comparar. No necesitas leer ni entender esos números tú mismo. La base de datos en el siguiente paso maneja todas las comparaciones por ti.

Si la descarga falla con un error de conexión, simplemente ejecuta el comando de nuevo. Se reanuda desde donde se quedó.

Paso 4: Almacena todo en tu base de datos vectorial

Ahora colocamos los fragmentos y sus embeddings en Chroma, tu base de datos local. Esto es lo que hace que la búsqueda sea rápida: en lugar de comparar tu pregunta con cada fragmento manualmente cada vez, Chroma los almacena listos y hace la coincidencia por ti. Se guarda en una carpeta de tu máquina, por lo que solo lo construyes una vez.

1. Configura la base de datos. Debajo del código del paso 3, en rag.py:

1import chromadb
2
3client = chromadb.PersistentClient(path="chroma_db")
4collection = client.get_or_create_collection("my_documents")

PersistentClient(path="chroma_db") le dice a Chroma que guarde en una carpeta llamada chroma_db (la crea automáticamente, justo al lado de tu script). Debido a que se guarda en disco, tus datos sobreviven después de que el script termine. Una collection es simplemente la caja con nombre donde viven tus fragmentos.

2. Añade tus fragmentos a la base de datos. Añade esto debajo:

1collection.add(
2    ids=[str(i) for i in range(len(all_chunks))],
3    embeddings=[emb.tolist() for emb in embeddings],
4    documents=[chunk["text"] for chunk in all_chunks],
5    metadatas=[{"source": chunk["source"]} for chunk in all_chunks],
6)
7
8print(f"Almacenados {collection.count()} fragmento(s) en la base de datos.")

Esto es lo que cada línea entrega a Chroma, en términos simples: ids le da a cada fragmento una etiqueta única (0, 1, 2...), embeddings son los números del paso 3, documents es el texto real del fragmento, y metadatas lleva el nombre del archivo para que podamos mostrar la fuente más tarde. Chroma mantiene los cuatro vinculados.

3. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

Deberías ver:

Almacenados 1 fragmento(s) en la base de datos.

Una cosa a tener en cuenta para más adelante. Cada vez que ejecutas el script ahora, vuelve a añadir los fragmentos, por lo que los recuentos pueden aumentar (1, luego 2, luego 3...) en ejecuciones repetidas. Eso está bien mientras estamos construyendo. Para empezar limpio, elimina la carpeta chroma_db y ejecuta una vez más. En la versión final manejaremos esto correctamente para que no se duplique.

Paso 5: Busca en tus documentos

Esta es la parte de "recuperación" de RAG, la R del nombre. Tomamos una pregunta, la convertimos en un embedding de la misma manera que hicimos con los fragmentos, y le pedimos a Chroma los fragmentos cuyo significado sea más cercano. Esos fragmentos coincidentes son lo que le daremos a Claude en el siguiente paso.

1. Añade la función de búsqueda. Debajo del código del paso 4, en rag.py:

1def search(question, n_results=3):
2    question_embedding = embedder.encode([question])[0]
3    results = collection.query(
4        query_embeddings=[question_embedding.tolist()],
5        n_results=n_results,
6    )
7    return results

Lo que hace esto, línea por línea en términos simples: convierte la pregunta en números con el mismo modelo que usaste en tus fragmentos (esto es importante, ambos deben hablar el mismo "idioma de números"), luego le pide a Chroma las coincidencias más cercanas. n_results=3 significa "dame los 3 fragmentos más relevantes". Tres es un buen valor predeterminado: suficiente contexto, no tanto como para desperdiciar tokens.

2. Prueba una búsqueda. Añade esto debajo para probarlo:

1question = "¿Quién dirige Northstar y cuándo se revisan los comentarios?"
2results = search(question)
3
4for i, doc in enumerate(results["documents"][0]):
5    source = results["metadatas"][0][i]["source"]
6    print(f"\n--- Coincidencia {i+1} (de {source}) ---")
7    print(doc)

Esto ejecuta una pregunta real contra tu base de datos e imprime los fragmentos que encontró, cada uno con el nombre del archivo del que proviene.

3. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

Con el archivo de prueba de Northstar, deberías ver que devuelve el fragmento coincidente, algo como:

--- Coincidencia 1 (de notes.txt) ---

Project Northstar es nuestra herramienta interna para el seguimiento de comentarios de clientes. Se lanzó en marzo de 2026 y la mantiene el equipo de plataforma. La ingeniera principal es Dana Reyes. Los comentarios se revisan todos los viernes. Northstar reemplazó el antiguo sistema de hojas de cálculo que usábamos hasta 2025.

Observa lo que acaba de suceder: tu pregunta usó las palabras "dirige" y "revisan", pero el archivo dice "ingeniera principal" y "revisan todos los viernes". Coincidió de todos modos, porque la búsqueda funciona por significado, no por palabras exactas. Ese es el objetivo de los embeddings, y es por eso que esto supera a una simple búsqueda de palabras clave (Ctrl+F) en tus archivos.

Si tienes más archivos, verás los 3 fragmentos principales de todos ellos, ordenados por qué tan cerca coinciden.

Paso 6: Haz que Claude responda a partir de lo que encontró

Esta es la parte de "generación", la G de RAG. Tomamos los fragmentos del paso 5, se los damos a Claude Opus 4.8 junto con la pregunta, y le decimos que responda usando solo ese contexto. Esto es lo que evita que adivine: Claude responde desde tus archivos, no desde su propia memoria, y te dice qué archivo usó.

1. Añade la función de respuesta. Debajo del código del paso 5, en rag.py:

1import anthropic
2
3claude = anthropic.Anthropic(api_key=api_key)
4
5def answer(question):
6    results = search(question)
7    chunks = results["documents"][0]
8    sources = [m["source"] for m in results["metadatas"][0]]
9
10    context = ""
11    for i, chunk in enumerate(chunks):
12        context += f"[De {sources[i]}]\n{chunk}\n\n"
13
14    message = claude.messages.create(
15        model="claude-opus-4-8",
16        max_tokens=1024,
17        system=(
18            "Responde a las preguntas usando solo el contexto proporcionado. "
19            "Si la respuesta no está en el contexto, di que no lo sabes. "
20            "Menciona siempre de qué archivo proviene tu respuesta."
21        ),
22        messages=[
23            {
24                "role": "user",
25                "content": f"Contexto:\n{context}\nPregunta: {question}",
26            }
27        ],
28    )
29    return message.content[0].text

Lo que sucede aquí, en términos simples: buscamos los fragmentos relevantes, los unimos en un bloque de contexto (cada uno etiquetado con su nombre de archivo), luego enviamos ese bloque más la pregunta a Claude. La instrucción system es la parte clave. Le dice a Claude tres cosas: responde solo a partir del contexto, admite cuando la respuesta no está allí, y nombra el archivo fuente. Esas tres reglas son lo que hace que las respuestas sean confiables en lugar de inventadas.

model="claude-opus-4-8" es el nombre exacto del modelo (guiones, no puntos). max_tokens=1024 limita la longitud de la respuesta.

2. Haz una pregunta. Añade esto debajo:

1question = "¿Quién dirige Northstar y cuándo se revisan los comentarios?"
2print(answer(question))

3. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

Deberías obtener una respuesta real construida a partir de tu archivo, algo como:

Dana Reyes es la ingeniera principal que dirige Project Northstar, y los comentarios se revisan todos los viernes. (Fuente: notes.txt)

Eso es un sistema RAG completo funcionando. Claude nunca vio este archivo durante el entrenamiento, no puede saber quién es Dana Reyes, sin embargo respondió correctamente y te dijo exactamente de dónde vino la respuesta. Pregúntale algo que no esté en tus archivos y dirá que no lo sabe, en lugar de inventar una respuesta. Ese "no lo sé" es una característica, no un fallo: es la diferencia entre una herramienta en la que puedes confiar y una que adivina.

Paso 7: Conviértelo en algo que realmente puedas usar

Ahora mismo tienes que editar el código y volver a ejecutar todo el script cada vez que quieras preguntar algo. Peor aún, cada ejecución vuelve a leer tus archivos y los vuelve a añadir a la base de datos, por lo que los fragmentos se acumulan. Arreglemos ambas cosas: construye la base de datos solo una vez, luego te permite hacer preguntas en un bucle, escribiéndolas directamente en la terminal.

1. Corrige la doble adición. Encuentra el bloque del paso 4 que añade fragmentos (la parte de collection.add(...)) y reemplázalo con esta versión, que solo construye la base de datos si está vacía:

1if collection.count() == 0:
2    collection.add(
3        ids=[str(i) for i in range(len(all_chunks))],
4        embeddings=[emb.tolist() for emb in embeddings],
5        documents=[chunk["text"] for chunk in all_chunks],
6        metadatas=[{"source": chunk["source"]} for chunk in all_chunks],
7    )
8    print(f"Almacenados {collection.count()} fragmento(s) en la base de datos.")
9else:
10    print(f"La base de datos ya tiene {collection.count()} fragmento(s), omitiendo reconstrucción.")

Ahora el trabajo pesado (leer archivos, hacer embeddings, llenar la base de datos) ocurre solo la primera vez. Las ejecuciones posteriores saltan directamente a responder.

2. Añade el bucle de preguntas. Al final de rag.py, reemplaza la pregunta de prueba única del paso 6 con esto:

1print("\nHaz una pregunta sobre tus documentos (o escribe 'salir' para terminar).\n")
2
3while True:
4    question = input("Tú: ")
5    if question.lower() in ["salir", "exit"]:
6        break
7    print("\nClaude: " + answer(question) + "\n")

input("Tú: ") espera a que escribas una pregunta y presiones Enter. while True lo mantiene en marcha para que puedas hacer tantas preguntas como quieras. Escribir "salir" lo detiene.

3. Ejecútalo. Guarda rag.py, luego en tu terminal:

1python rag.py

Ahora puedes simplemente hablar con tus archivos:

Haz una pregunta sobre tus documentos (o escribe 'salir' para terminar).

Tú: ¿quién es la ingeniera principal de Northstar?

Claude: La ingeniera principal de Project Northstar es Dana Reyes. (Fuente: notes.txt)

Tú: ¿qué reemplazó?

Claude: Northstar reemplazó el antiguo sistema de hojas de cálculo que se usaba hasta 2025. (Fuente: notes.txt)

Tú: salir

Ese es tu sistema RAG terminado. Lee tus archivos una vez, los recuerda y responde preguntas sobre ellos bajo demanda, siempre con la fuente.

Una cosa a tener en cuenta cuando añadas nuevos archivos. Debido a que la base de datos ahora se construye solo una vez, colocar nuevos archivos en documents no aparecerá automáticamente. Para cargar nuevos archivos, elimina la carpeta chroma_db y ejecuta el script una vez. Se reconstruye desde cero con todo lo que hay en la carpeta.

Opcional: dale una ventana de chat en tu navegador

La terminal funciona, pero si quieres una ventana de chat real, Streamlit añade una en unas 20 líneas.

1. Instálalo. En tu terminal:

1pip install streamlit

2. Crea app.py en la misma carpeta y pega esto. Reutiliza la función answer de tu rag.py:

1import streamlit as st
2from rag import answer
3
4st.title("Chatea con tus documentos")
5
6if "history" not in st.session_state:
7    st.session_state.history = []
8
9question = st.chat_input("Pregunta sobre tus archivos...")
10
11if question:
12    reply = answer(question)
13    st.session_state.history.append((question, reply))
14
15for q, a in st.session_state.history:
16    st.chat_message("user").write(q)
17    st.chat_message("assistant").write(a)

3. Ejecútalo. En tu terminal (nota: streamlit run, no python):

1streamlit run app.py

Se abre una ventana de chat en tu navegador automáticamente. Escribe una pregunta, obtén una respuesta con su fuente, igual que en la terminal pero más bonito a la vista.

Una nota: para que esto funcione, el bucle de preguntas del paso 7 no debe ejecutarse al importar. Envuelve ese bucle al final de rag.py en if __name__ == "__main__": para que solo se active cuando ejecutes rag.py directamente, no cuando app.py lo importe.

Permitir que también responda preguntas generales

Si quieres que también responda preguntas generales. Ahora mismo el sistema solo responde desde tus archivos, por lo que una pregunta como "¿cuál es la capital de Venezuela?" obtiene "eso no está en los documentos", aunque Claude sepa la respuesta. Si quieres que recurra a su propio conocimiento, abre rag.py, busca el bloque system=(...) en el paso 6, y cambia esta línea:

1"Si la respuesta no está en el contexto, di que no lo sabes."

para esto:

1"Si la respuesta no está en el contexto, responde desde tu propio conocimiento general, pero di que lo estás haciendo."

Guarda y vuelve a ejecutar. Ahora responde primero desde tus archivos, y si no están cubiertos, recurre al conocimiento general, indicándote cuál usó.

Conclusión

Acabas de construir un sistema RAG funcional. Lee tus propios archivos, encuentra las partes relevantes y hace que Claude responda basándose en ellos, indicando siempre la fuente exacta. La misma configuración escala desde unas pocas notas hasta toda tu base de conocimiento.

A partir de aquí, puedes orientarlo hacia donde quieras: tu bóveda de Obsidian, tus documentos de trabajo, tus investigaciones guardadas. Coloca los archivos, recompila una vez y empieza a preguntar. Todo lo que has aprendido aquí (los fragmentos, los embeddings, la búsqueda, la respuesta) es el mismo motor que está detrás de cada herramienta de "chatea con tus documentos" que hayas visto.

Si te fue útil, ve a mi perfil y sígueme. Escribo sobre tecnología, IA y sistemas que realmente funcionan.

Ciao,

[@undefinedKi**](https://x.com/@undefinedKi