Experimento: búsqueda semántica con ChromaDB​

Contexto: indexar 5 textos en ChromaDB con embeddings automáticos y recuperar el más relevante para una consulta.

pip install chromadb

import chromadb

client = chromadb.Client()
collection = client.create_collection("fragmentos")

# Indexar documentos (ChromaDB genera embeddings automáticamente)
collection.add(
    documents=[
        "Los transformers son la arquitectura dominante en NLP.",
        "Ollama permite ejecutar LLMs en local sin coste por token.",
        "La cuantización reduce el tamaño del modelo con pérdida mínima de calidad.",
        "RAG combina recuperación de documentos con generación de texto.",
        "El fine-tuning adapta un modelo a un dominio específico.",
    ],
    ids=["doc1", "doc2", "doc3", "doc4", "doc5"]
)

# Consulta semántica
resultados = collection.query(
    query_texts=["¿Cómo ejecuto un modelo de IA en mi ordenador?"],
    n_results=2
)

for doc, dist in zip(resultados["documents"][0], resultados["distances"][0]):
    print(f"[{dist:.3f}] {doc}")

Resultado:

[0.312] Ollama permite ejecutar LLMs en local sin coste por token.
[0.489] La cuantización reduce el tamaño del modelo con pérdida mínima de calidad.

Qué aprender: ChromaDB genera los embeddings internamente y devuelve distancias (menor = más similar). Sin escribir una sola línea de código de vectorización, ya tienes búsqueda semántica funcional. Para proyectos pequeños y prototipos es más que suficiente.

Referencias​

• ChromaDB — Documentación
• ChromaDB — GitHub
• Notas: ChromaDB

Este built-in slash command de Claude Code nos ahorra tiempo analizando el proyecto automáticamente y produciendo un fichero de contexto útil desde el primer momento.

1. Ejecutamos claude en nuestro proyecto existente y ejecutamos el comando /init:

2. Claude analizará nuestro proyecto para generar el fichero CLAUDE.md:

3. Tras la ejecución de /init, Claude Code tendrá mayor contexto para trabajar en el proyecto:

🤓 Podemos editar el fichero CLAUDE.md generado para añadir restricciones o convenciones específicas de tu proyecto.

Referencias​

• Configuración de CLAUDE.md
• Notas: CLAUDE.md y directorio .claude

1. Instalamos Ollama y descargamos el modelo que queramos usar para analizar los documentos.

2. Instalamos AnythingLLM y lo ejecutamos.

Si pulsamos "Comenzar", nos sugiere un modelo adecuado a nuestros recursos hardware, pero lo que queremos es usar Ollama como proveedor de modelos.

3. Seleccionamos "Configuración manual" y localizamos "Ollama":

4. Elegimos un modelo de entre los que tenemos disponibles en Ollama y terminamos el proceso de configuración inicial:

5. Creamos un espacio de trabajo (workspace) al que adjuntar documentos y preguntarle a nuestro modelo local:

6. Subimos un PDF al espacio de trabajo y lo pineamos:

7. Y finalmente podemos hacerle preguntas sobre el contenido adjunto al espacio de trabajo:

Referencias​

• AnythingLLM — Sitio oficial
• AnythingLLM — Documentación
• Notas: AnythingLLM

Experimento: crear una skill de commit​

Contexto: automatizar el flujo de commit con Conventional Commits para no tener que recordar el formato cada vez.

mkdir -p .claude/commands
cat > .claude/commands/commit.md << 'EOF'
Revisa los cambios en staging con `git diff --cached`.
Redacta un mensaje de commit siguiendo Conventional Commits (feat/fix/docs/refactor...).
Muéstrame el mensaje propuesto y espera confirmación antes de hacer el commit.
EOF

/commit

Resultado:

Cambios en staging:
  M src/auth/login.ts — añadida validación de email

Mensaje propuesto:
  feat(auth): añadir validación de formato de email en login

¿Confirmas el commit? (s/n)

Qué aprender: las skills convierten instrucciones largas y repetitivas en un comando de una palabra, manteniendo consistencia entre sesiones y miembros del equipo.

Referencias​

• Referencia de comandos y atajos
• Notas: Skills y comandos

Sin AGENTS.md, Codex puede tocar ficheros generados o ignorar convenciones del proyecto, así que creamos este archivo en la raíz de nuestro proyecto:

# AGENTS.md

## Comandos
```bash
npm test
npm run build

Restricciones​

• No modifiques ficheros en src/generated/ ni en dist/
• Usa siempre async/await, nunca .then()
• Los tests van en tests/ junto al fichero que prueban

## Referencias

- [Codex CLI — Repositorio oficial](https://github.com/openai/codex)
- [Notas: AGENTS.md](/notes/tools/ai-coding/codex/agents-md)

Experimento: Codex con Ollama en local​

Contexto: usar Codex sin enviar código a servidores externos, útil para proyectos privados o con restricciones de privacidad.

ollama pull qwen2.5-coder:7b

export OPENAI_BASE_URL="http://localhost:11434/v1"
export OPENAI_API_KEY="ollama"
codex --model qwen2.5-coder:7b "explica qué hace la función main en src/index.ts"

Resultado:

Leyendo src/index.ts...

La función `main` inicializa el servidor Express, registra los middlewares de
autenticación y logging, monta las rutas desde src/routes/, y arranca el servidor
en el puerto definido en la variable de entorno PORT (por defecto 3000).

Qué aprender: con qwen2.5-coder:7b y 8 GB de RAM obtienes un agente de código completamente local. La velocidad es menor que con la API de OpenAI, pero suficiente para tareas de análisis y edición de ficheros.

Referencias​

• Codex CLI — Repositorio oficial
• Ollama — Sitio oficial
• Notas: Codex CLI — Modelos

Experimento: ejecutar un LLM sin instalar nada​

Contexto: llamafile es la forma más rápida de probar un modelo en cualquier máquina, sin configuración.

wget https://huggingface.co/Mozilla/Llama-3.2-1B-Instruct-llamafile/resolve/main/Llama-3.2-1B-Instruct.Q6_K.llamafile
chmod +x Llama-3.2-1B-Instruct.Q6_K.llamafile
./Llama-3.2-1B-Instruct.Q6_K.llamafile --cli -p "¿Qué es un transformer?"

Resultado:

Un transformer es una arquitectura de red neuronal basada en el mecanismo de atención,
introducida en el paper "Attention Is All You Need" (2017). Es la base de la mayoría
de los modelos de lenguaje modernos como GPT, BERT y LLaMA.

Qué aprender: sin npm install, sin pip install, sin Docker. Descarga, permiso, ejecuta. El flag --cli activa el modo de línea de comandos en lugar de abrir el navegador.

Referencias​

• llamafile — GitHub (Mozilla)
• Modelos llamafile en HuggingFace
• Notas: llamafile

Experimento: usar LM Studio como backend de la API de OpenAI​

Contexto: LM Studio permite reutilizar código escrito para la API de OpenAI apuntando a un modelo local sin coste por token.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Explica qué es la cuantización en una frase."}]
)
print(response.choices[0].message.content)

Resultado:

La cuantización reduce la precisión numérica de los pesos de un modelo (por ejemplo,
de 32 bits a 4 bits) para disminuir su tamaño en memoria y acelerar la inferencia,
con una pequeña pérdida de calidad.

Qué aprender: con LM Studio arrancado en modo servidor, el mismo código que usas con la API de OpenAI funciona en local sin modificaciones, solo cambiando base_url.

Referencias​

• LM Studio — Sitio oficial
• Notas: LM Studio

Experimento: embeddings locales con nomic-embed-text​

Contexto: generar embeddings sin enviar datos a ningún servicio externo, útil para RAG privado.

import ollama

textos = [
    "Ollama permite ejecutar LLMs en local.",
    "Los embeddings son representaciones vectoriales del texto.",
]

for texto in textos:
    result = ollama.embeddings(model="nomic-embed-text", prompt=texto)
    print(f"Dimensiones: {len(result['embedding'])}")

Resultado:

Dimensiones: 768
Dimensiones: 768

Qué aprender: nomic-embed-text genera vectores de 768 dimensiones, compatibles con la mayoría de bases de datos vectoriales como ChromaDB o Qdrant.

Referencias​

• Librería Python de Ollama
• Catálogo de modelos
• Notas: Casos de uso de Ollama

Experimento: crear un asistente personalizado con Modelfile​

Contexto: fijar un system prompt y ajustar parámetros evita tener que repetirlos en cada sesión.

cat > Modelfile <<'EOF'
FROM llama3.2
SYSTEM "Eres un asistente técnico especializado en Python. Responde siempre en español y sé conciso."
PARAMETER temperature 0.3
PARAMETER num_ctx 4096
EOF

ollama create asistente-python -f Modelfile
ollama run asistente-python "¿Cuál es la diferencia entre list y tuple?"

Resultado:

Lista (list): mutable, puedes añadir, eliminar o modificar elementos.
Tupla (tuple): inmutable, no se puede modificar tras su creación.
Usa tuple cuando los datos no deben cambiar; es ligeramente más rápida y consume menos memoria.

Qué aprender: con temperature 0.3 las respuestas son más deterministas y directas, ideal para asistentes técnicos.

Referencias​

• Referencia de Modelfile
• Notas: Configuración de Ollama

Experimento: levantar Open WebUI con Ollama en un comando​

Contexto: la imagen ollama de Open WebUI incluye Ollama, por lo que no hace falta tenerlo instalado previamente.

docker run -d -p 8080:8080 \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  ghcr.io/open-webui/open-webui:ollama

Resultado:

Unable to find image 'ghcr.io/open-webui/open-webui:ollama' locally
ollama: Pulling from open-webui/open-webui
...
Status: Downloaded newer image for ghcr.io/open-webui/open-webui:ollama
a3f1c2d8e9b0...

Abre http://localhost:8080, crea una cuenta de administrador y ya puedes descargar modelos desde la interfaz.

Qué aprender: con un solo comando tienes un ChatGPT local completo. El volumen ollama persiste los modelos entre reinicios del contenedor.

Referencias​

• Open WebUI — Documentación
• Open WebUI — GitHub
• Notas: Open WebUI

Experimento: búsqueda semántica en PostgreSQL​

Contexto: añadir búsqueda semántica a una base de datos PostgreSQL existente con una sola extensión.

-- Habilitar extensión
CREATE EXTENSION vector;

-- Tabla con columna de embedding
CREATE TABLE fragmentos (
  id SERIAL PRIMARY KEY,
  texto TEXT,
  embedding vector(3)  -- 3 dimensiones para el ejemplo
);

-- Insertar datos con embeddings
INSERT INTO fragmentos (texto, embedding) VALUES
  ('Los transformers dominan el NLP', '[0.1, 0.8, 0.3]'),
  ('Ollama ejecuta LLMs en local',    '[0.9, 0.1, 0.2]'),
  ('RAG mejora la precisión del LLM', '[0.4, 0.6, 0.7]');

-- Buscar el más similar a un vector de consulta
SELECT texto, embedding <=> '[0.85, 0.15, 0.25]' AS distancia
FROM fragmentos
ORDER BY distancia
LIMIT 2;

Resultado:

texto                           | distancia
--------------------------------+----------
Ollama ejecuta LLMs en local    | 0.018
Los transformers dominan el NLP | 0.412

Qué aprender: <=> es el operador de distancia coseno. Con un índice HNSW (CREATE INDEX ON fragmentos USING hnsw (embedding vector_cosine_ops)) la búsqueda escala a millones de filas sin degradación notable.

Referencias​

• pgvector — GitHub
• PostgreSQL — Documentación
• Notas: pgvector

Experimento: búsqueda híbrida con Weaviate​

Contexto: combinar búsqueda vectorial y BM25 para obtener resultados más relevantes que con un solo método.

import weaviate

client = weaviate.connect_to_local()

collection = client.collections.get("Documento")

# Búsqueda híbrida: vectorial + BM25
results = collection.query.hybrid(
    query="modelos de lenguaje en local",
    alpha=0.5,   # 0 = solo BM25, 1 = solo vectorial
    limit=3
)

for obj in results.objects:
    print(obj.properties["contenido"])

client.close()

Resultado:

Ollama permite ejecutar LLMs en local sin coste por token.
La cuantización reduce el tamaño del modelo con pérdida mínima de calidad.
LM Studio incluye un servidor local compatible con la API de OpenAI.

Qué aprender: el parámetro alpha controla el balance entre búsqueda semántica y textual. alpha=0.5 suele dar mejores resultados que cualquiera de los dos métodos por separado.

Referencias​

• Weaviate — Documentación
• Weaviate — GitHub
• Notas: Weaviate

Chatbot Arena es una plataforma de evaluación colaborativa de modelos desarrollada por LMSYS que nos permite comparar respuestas de dos modelos y votar la mejor.

Para comparar dos modelos podemos seguir los siguientes pasos:

1. Accedemos a la web de Chatbot Arena.
2. Elegimos el modo Side by Side: Comparar dos modelos de nuestra elección.

Hay otros dos modos:

• Battle Mode: Comparar dos modelos aleatorios.
• Direct: Chatear con un modelo directamente.

3. Le hacemos una consulta.

4. Elegimos qué respuesta consideramos que es la mejor (pueden ser ambas o ninguna).

5. Nuestro voto actualiza el ranking Elo.

El leaderboard​

El resultado acumulado de todos los votos genera un ranking Elo público que refleja preferencia humana real, no benchmarks de laboratorio. Es la métrica más usada como referencia para comparar la calidad percibida de los modelos frontier.

Para poder ejecutar un modelo (LLM), necesitamos un motor de ejecución (runtime), y para en este experimento usaremos Ollama.

1. Instalamos Ollama​

Sigue estas instrucciones para instalar Ollama en tu sistema.

2. Descargamos un modelo​

Se descarga el modelo del repositorio de modelos de Ollama:

$ ollama pull llama3.2

3. Lo ejecutamos​

Chateamos con el modelo:

$ ollama run llama3.2
>>> ¿Qué es un modelo de lenguaje en una frase?
Un modelo de lenguaje es un sistema informático que utiliza algoritmos y técnicas de procesamiento del lenguaje natural para entender, 
generar y interactuar con texto. Estos modelos están diseñados para aprender patrones y estructuras del lenguaje a partir de grandes 
conjuntos de datos y luego utilizar esta información para realizar tareas específicas como la traducción automática, la pregunta respuesta 
o la generación de contenido.

>>> /bye

En cuestión de minutos tenemos un LLM corriendo en local, sin cuenta, sin API key, sin coste por token.