Un ordenador no puede entender texto ni relaciones semánticas o significados entre palabras. Solo puede entender números. Este problema lo resolvemos mediante el uso de embeddings.

Un embedding es la representación de texto (en forma de números) en un espacio vectorial. Esto permite a los modelos de IA comparar y operar sobre el significado de las palabras.

flowchart TD
    A["perro"] --> B{{Modelo de embedding}}
    B --> C["[-0.003, 0.043, ..., -0.01]"]
    
    N1["(texto que queremos convertir)"]:::note --> A
    N2["(vectores con contenido semántico)"]:::note --> C
    
    classDef note fill:none,stroke:none,color:#777;    

Los vectores de cada palabra o documento capturan el significado semántico del texto.

• perro estará cerca de mascota
• contrato estará lejos de playa

Vector vs SQL databases

El problema con las bases de datos típicas es que solo buscan matches exactos. Si yo busco por coche solo me sacará las entradas que contengan coche.

En cambio las BBDD vectoriales pueden interpretar la semántica de las palabras mediante vectores. Si busco por coche puede sacarme valores como sedán, SUV, Land Rover, etc.

Las BBDD vectoriales son muy buenas cuando necesitamos buscar items similares por proximidad uno respecto al otro.

Algunos ejemplos de uso son:

• buscar películas parecidas (Netflix)
• Recomendadores de items parecidos en tiendas online (Amazon)
• buscar canciones parecidas (Spotify)

Read More

(este post es una explicación de la teoría. dejo aquí otro post con el detalle práctico de como usar la temperature, top_k y top_p a efectos prácticos)

Explicación más en detalle de cómo obtienen los LLMs las probabilidades para generar el siguiente token

Sampling

En cada posición el modelo tiene una bolsa con miles de tokens posibles. Sampling es el proceso de no coger siempre el token más probable, si no de orientarlo a coger respuestas con determinadas características.

Si el modelo escogiera siempre el token con más probabilidades, obtendríamos respuestas aburridas y repetitivas.

Logits

Para generar el siguiente token, una red neuronal calcula primero los vectores de logits, donde cada logit corresponde a un valor posible. El tamaño de estos vectores de logits es tan grande como el vocabulario completo del modelo.

(representación de vectores de logits)

flowchart LR
	N1["What's your favorite color?"]:::note --> Z
	Z --> A1 --> A
	Z --> B1 --> B
	Z --> C1 --> C
	Z --> D1 --> D
	
	Z["Neural network"]
    A["a"]
    A1["(-0.5)"]
    B["green"]
    B1["(0.7)"]
    C["red"]
    C1["(0.5)"]
    D["the"]
    D1["(-1.2)"]
    
    classDef note fill:none,stroke:none,color:#777;    

Los logits NO representan probabilidades ya que no suman 1 y pueden incluso ser negativos (la probabilidades no pueden). Para convertir logits a probabilidades se usa una Softmax layer

Temperature

La temperatura es una constante que se aplica a los logits antes de la transformación de la Softmax layer. Se usa para ajustar la creatividad del modelo y redistribuir la probabilidad de los valores. Una temperatura más alta hace que el modelo sea más creativo ya que aumenta las posibilidades de elegir tokens menos probables.

xychart-beta
  title "Temperatura vs Probabilidad"
  x-axis "Temperatura (T)" [0.1, 0.2, 0.5, 1, 2, 5]
  y-axis "Probabilidad" 0 --> 1
  line "P(token1)" [0.9999546, 0.9933071, 0.8807971, 0.7310586, 0.6224593, 0.5498340]
  line "P(token2)" [0.0000454, 0.0066929, 0.1192029, 0.2689414, 0.3775407, 0.4501660]

Ejemplos de temperaturas:

• Low (0.2-0.3): El modelo es cauto y elige las palabras más probables. Output factual y predecible.
• Medium (0.5-0.7): Un mix de confiabilidad y engagement
• High (0.9-1.0): Toma riesgos y es impredecible

Read More

Los hyperparámetros son settings de configuración, los cuales se configuran manualmente para optimizar la eficiencia o la creatividad de la respuesta

Temperature (creatividad)

La temperatura controla probabilidad de distribución del modelo a la hora de elegir las siguientes palabras:

xychart-beta
  title "Temperatura vs Probabilidad"
  x-axis "Temperatura (T)" [0.1, 0.2, 0.5, 1, 2, 5]
  y-axis "Probabilidad" 0 --> 1
  line "P(token1)" [0.9999546, 0.9933071, 0.8807971, 0.7310586, 0.6224593, 0.5498340]
  line "P(token2)" [0.0000454, 0.0066929, 0.1192029, 0.2689414, 0.3775407, 0.4501660]

• Low (0.2-0.3): El modelo es cauto y elige las palabras más probables. Output factual y predecible.
• Medium (0.5-0.7): Un mix de confiabilidad y engagement
• High (0.9-1.0): Toma riesgos y es impredecible

Respuesta posibles con la siguiente frase

Once upon a time, there was a dragon…

• Temp 0.2: …who lived in a cave guarding treasure
• Temp 0.7: …who dreamed of becoming friends with the villagers
• Temp 1.0: …who loved baking cookies and singing karaoke

Cuanta más alta la temperatura, más imaginativo, creativo y loco es el modelo, lo cual no siempre es bueno. Para usos creativos se suele usar una temperatura de 0.7.

Top-k (candidate pool fija)

Top-k es una estrategia de sampling para filtrar el número de candidatos a los más probables. Fuerza al modelo a elegir el siguiente token sobre una pool k de candidatos.

Es una estrategia de sampling de tamaño fijo, una vez tenemos computados los logits. Ayuda a reducir el número de candidatos sobre los que se calculan la softmax layer.

Candidatos posibles con la siguiente frase

I like to drink…

• small k (5): El modelo solo tiene unas pocas elecciones posibles, las cuales serán las más seguras posibles. Ej: [water, coffee, tea, juice, milk]
• large k (50): El modelo puede elegir entre opciones muy amplias. Amplía la variedad pero también la posibilidad de que salgan resultados inesperados Ej: […, smothies, kombucha, cocktails, hot chocolate, …]

(!) La contra que tiene es que si el modelo está muy seguro, puede incluir tokens con una baja probabilidad solo por el hecho de que tiene que llegar hasta k candidatos. (!)

Read More

Chunking es el proceso de partir la información que contienen nuestros documentos en pedazos digestibles. Estos chunks los usaremos después para hacer queries contra ellos.

A veces si parece que no obtenemos los resultados que queremos de nuestras queries no es por falta de información, si no por un chunking mal hecho. Si hacemos una query y por cómo hemos partido nuestros documentos tenemos la pregunta en un chunk y partes de la respuesta divididas entre múltiples chunks sin solapamiento, no obtendremos buenas respuestas.

La idea es simple, el proceso no tanto. Hay varias técnicas según lo que nos queramos complicar y los resultados que obtenemos varían entre ellas.

Chunking estático

El más simple. Tenemos un documento y partimos cada chunk en grupos de (por ejemplo) 500 tokens con 100 tokens de solapamiento entre chunks.

Tenemos la siguiente frase de prueba

La casa grande es bonita aunque cara, pero tiene un buen garaje. En el futuro quiero comprarme un coche

Visualizando los tokens a nivel de subpalabra con test-multilingual-embedding me salen 28 tokens aprox.

Si establecemos un limite de 10 tokens por chunk, con 3 de solapamiento, cada chunk se podría ver así:

La casa grande es bonita aunque cara
aunque cara, pero tiene un buen garaje
buen garaje. En el futuro quiero comprar
quiero comprarme un coche

El problema es que puede cortar frases a media palabra según como coincida ya que la palabra comprarme son dos tokens comprar y me

Esto se puede aliviar un poco con librerías de chunking inteligente que existen que parten usando separadores como espacios o saltos de línea, pero el contexto se puede perder mucho si cae entre varios chunks.

Chunking semántico

Una técnica que solventa esto es hacer el chunking mediante un modelo de embedding, el cual parte los chunks por contenido semántico cuando detecta que el tema principal cambia. Es más caro porque un modelo tiene que analizar los documentos, pero da mejores resultados.

De esta manera el mismo texto nos quedaría en dos chunks que aunque tienen distinto tamaño, están mucho más contenidos, por lo que a la hora de buscar con una query nos dará mejores resultados.

La casa grande es bonita aunque cara, pero tiene un buen garaje.
En el futuro quiero comprarme un coche

Limpieza

Limpiar los chunks es tan importante como el dónde partir. En mis primeras pruebas se metía mucho ruido en cosmos por como \n o \t o chunks que solo contenían un número sin contexto ninguno.

Para sistemas grandes o genéricos puede ser importante meter metadatos junto a los chunks para filtrar luego al buscar. Cosas como el nombre del documento al que pertenece un chunk o la fecha de creación del documento ayudan a filtrar luego y favorecer documentación reciente o saber de dónde viene algún dato erróneo o con menor calidad.

Foundation Models

Los foundation models son modelos de IA generalistas entrenados con datasets diversos y masivos, que están listos para ser adaptados a muchos tipos de tareas diferentes.

Sobre todo NO están limitados a lenguaje escrito. Pueden trabajar con cualquier variación de: Texto, Imagen, Audio, Video y Código.

LLM (Large Language Model)

Los LLMs son sistemas estocásticos (no deterministas) entrenados para generar predicciones de texto basadas en prompts. Sus datos de entrenamiento se basan sobre todo en texto / código y se especializan en lectura / escritura y lenguaje oral. El truco está en que el modelo entienda la relación semántica entre palabras, y qué palabras de una secuencia son las que tienen más probabilidades de influir en la siguiente; el modelo usa esto para predecir cual es la siguiente palabra más probable en la secuencia.

Un LLM no tiene “memoria” como tal. Las conversaciones como tal no existen para ellos. Cada input de una conversación contiene todo lo que se ha hablado antes.

Al igual que tenemos LLMs, también existen SLMs (small language models). La diferencia se basa en el volumen de datos con el que han sido entrenados y en el número de variables, aunque no hay límites definidos.

Ventana de contexto (Context Window)

La ventana de contexto es el limite de memoria que tiene un LLM. Determina cuánto de la conversación actual puede “mantener en memoria” el modelo.

Si la ventana es suficiente, el modelo podrá mantener la totalidad de la conversación en memoria, pero si nos pasamos del límite, el modelo comenzará a olvidarse de las primeras partes de la conversación, y comenzará a dar respuestas más vagas o alucinar.

Tokenization

El vocabulario de los LLMs se basa en cientos de miles de tokens, los cuales se basan en graaaandes volúmenes de datos de entrenamiento.

Los tokens se componen de palabras (perro, gato) pero también de partículas (“in” de “innecesario” o de “incomprensible”), puntuación (“casa” y “casa.” son tokens diferentes) y otras secuencias de caracteres.

Ejemplo de tokenization:

• I (1)
• heard (2)
• a (3)
• dog (4)
• bark (5)
• at (6)
• a (3) (already assigned before)
• tree (8)

Cuantos más datos de entreno, más tokens y más vocabulario tendrá.

Transforming tokens with a transformer

Ahora que tenemos una serie de tokens con un id único. Tenemos que relacionarlos entre ellos.

Para esto, le asignamos a cada token un vector. Un vector es una lista de números con múltiples dimensiones.
Un ejemplo de vector puede ser [0.25, 0.88, -0.47, 0.91]

Una vez tenemos inicializado este vector con valores aleatorios, utilizamos las dimensiones del vector para hacer un encoding lingüístico y asignarles el valor semántico del token (qué significa y como se relaciona con otros tokens).

Because this new vectors have semantic values embedded in them, we call them embeddings

Read More

TL;DR

Stack a usar:

• python -> lenguaje e intérprete
• py -> python launcher para windows
• pipx -> instalar tools python globales
• .env -> variables de entorno local; UAT y PROD usar config de donde se despliegue
• pyenv -> gestor de versiones de Python
• poetry -> gestor de proyecto. Abstrae pip y sustituye venv y requeriments.txt. Detalles de como usar poetry aquí

No usar pero si conocer (están explicados debajo):

• pip -> gestor de paquetes - incluye uso de requirements.txt (sustituir por poetry)
• pip3 -> No usarlo. Leftover histórico de cuando python2 y python3 convivian hasta el 2020
• venv -> entornos virtuales para aislamiento (sustituir por poetry)
• conda -> package y environment manager para data science & ML

Investigar de cara a futuro si uso python de manera más regular:

• uv -> gestor ultrarrápido de dependencies y entornos Python. Reemplaza a pip, venv, pip-tools y poetry. Soluciona la lentitud del stack clásico. Es reciente y está ganando tracción.

  Stack a usar

  Python (lenguaje/intérprete)

  Python como tal es el lenguaje y el intérprete. Es un lenguaje interpretado (no compilado) sobre una MV propia. Python por sí mismo no gestiona dependencias ni aislamiento.

Python. Solo. Ejecuta. Código.

(py) python en Windows

Python no es un único ejecutable, puedes tener varios intérpretes instalados a la vez. El caos general de python viene normalmente a que cada uno es una versión distinta, con librerías distintas y sus propios paths.

python.exe
python3.exe
py.exe

Si usas python, lo que hace el sistema es buscar python en $PATH y usar el primero que encuentre

python main.py

En windows usar siempre py. Está diseñado para gestionar múltiples versiones de Python (sólo en windows)

py # lanza la version por defecto. Normalmente el último Python3 instalado
py -3.11
py -0p # muy útil para debuggear todas las instalaciones detectadas

(!) No usar python y py indistintamente (!)

No se puede usar indistintamente python y py ya que son comandos diferentes.

# DON'T DO THIS
python -m venv .venv
.venv/Scripts/activate
pip install fastapi
py main.py # puede ignorar el .venv activado y lanzar un python global distinto

Read More

(Awesomes github copilot - buena página para encontrar skills e instructions reutilizables)

MCP (Model Context Protocol)

Un MCP Server es un componente que implemente el protocolo MCP, un estándar abierto diseñado para conectar LLMs y agentes de IA con datos y herramientas externas de forma segura y estándar.

El MCP server expone el contexto que necesita e indica las acciones que el agente puede usar a demanda.

Dotan a los LLMs de capacidades adicionales permitiendo:

• Acceso a datos en tiempo real: conectar la IA a APIs, BBDD, archivos locales…
• Automatizaciones: permiten conectar un componente a tools externas para ejecutar acciones (ejecutar flujos, crear registros, aprobar procesos)

Sin esto, los LLMs por sí solos están limitados a sus datos de entrenamiento.

(ejemplo de consumo real de MCP de Github desde Cursor. Gracias a él Cursor puede modificar issues o crear/cerrar PRs)

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer github_pat_"
      }
    }
  }
}

Componentes

MCP se compone de 3 partes:

• Host: es tu aplicación de IA. Claude Desktop, Cursor, etc. Es aquello que necesita conectarse a algo.
• Client: está dentro del host y administra conexiones MCP. Gestiona autenticación, hacer routing de requests al servidor correcto y administrar el ciclo de vida de la sesión.
• Server: expone una herramienta o data source a través de 3 primitivos
  • Tools: Acciones que el modelo puede hacer "Crea un ticket de JIRA"
  • Resources: Datos que el modelo puede leer "Los últimos 50 mensajes de #IA"
  • Prompts: Templates reusables que combinan ambas para workflows comunes "Resume la actividad de JIRA de hoy y crea un reporte"

Skills

Las skills son un estandar abierto que extiende lo que un agente es capaz de hacer con conocimiento y workflows especializados y reutilizables. Estas se cargan dinámicamente, generalmente en un SKILL.md y el propio agente decide cuando es necesario utilizarlas en base a la tarea que tiene entre manos.

Una vez declaradas el LLM puede decidir usarlas automáticamente o se pueden usar mediante /{nombre-skill} {opt-params}

(ejemplo de SKILL.md con Caveman, el cual reduce el número de tokens consumidos manteniendo la calidad de la respuesta)

Read More

(ver otras herramientas de Python y como se integran con pipx)

Install

# install
py -m pip install --user pipx

# only the first time we install something 
pipx ensurepath
# close and open terminal again

Usage

# build, install and run with poetry to make sure everything works
poetry build
poetry install
poetry run

# install localy with pipx
pipx install .

# now we're able to run it from anywhere
file-enlarger

in this case we invoke it as file-enlarger as the .toml declares it as such

[tool.poetry.scripts]
file-enlarger = "file_enlarger.enlarge_file:main"

Read More

(Oficial Doc)

Technology to quickly set up a Kubernetes cluster locally to learn how to use Kubernetes.

Installation

Install Docker Desktop for windows and start it.
Then install minikube through CLI or download here the exe

winget install Kubernetes.minikube

Now run

minikube start

Read More

(ver definición de Poetry y como se integra con otras herramientas Python)

Prerequisites

First of all install pip and use pip to install pipx. From then on, use only pipx

install pip tools

py -m pip install --user pip-tools

# upgrade pip
py -m pip install --upgrade pip

install pipx

py -m pip install --user pipx

# adds executables to global path so you can call them without py -m ...
py -m pipx ensurepath
# close and reopen console

install poetry through pipx

py -m pipx install --user poetry

Read More