El mundo de los grandes modelos de lenguaje (LLM) se está expandiendo a un ritmo explosivo, pero durante mucho tiempo, acceder a capacidades de vanguardia significaba depender de APIs basadas en la nube. Esta dependencia a menudo conlleva preocupaciones sobre la privacidad, el costo y la personalización. Sin embargo, la situación está cambiando gracias a potentes modelos de código abierto y herramientas como Ollama que facilitan más que nunca su ejecución en tu máquina local.
Entre los desarrollos recientes más emocionantes se encuentra el lanzamiento de la familia de modelos Qwen3 por Alibaba Cloud. Estos modelos, particularmente las versiones especializadas de *embedding* y *reranker*, están estableciendo nuevos puntos de referencia en rendimiento. Cuando se combinan con Ollama, proporcionan un potente conjunto de herramientas para desarrolladores e investigadores que buscan construir aplicaciones de IA sofisticadas, como motores de búsqueda avanzados y sistemas de Generación Aumentada por Recuperación (RAG), todo desde la comodidad de su propio hardware.
Este artículo es tu guía completa y paso a paso para aprovechar este poder. Desmitificaremos qué son los modelos de *embedding* y *reranker*, explicaremos la configuración de Ollama y proporcionaremos código Python práctico para ejecutar los modelos de *embedding* y *reranker* de Qwen3 para un flujo de trabajo RAG completo de principio a fin.
¿Quieres una plataforma integrada y todo en uno para que tu equipo de desarrolladores trabaje junto con la máxima productividad?
¡Apidog cumple con todas tus demandas y reemplaza a Postman a un precio mucho más asequible!
El Dúo Poderoso: Comprendiendo los Modelos de Embedding y Reranker
Antes de sumergirnos en el "cómo", entendamos el "qué". En el contexto de un sistema RAG, los modelos de *embedding* y *reranker* desempeñan roles distintos pero complementarios.
1. El Bibliotecario: El Modelo de Embedding
Imagina una biblioteca masiva con millones de libros pero sin un sistema de catálogo. Encontrar información sería una pesadilla. Un modelo de *embedding* es como un bibliotecario hiperinteligente que lee cada documento y le asigna una ubicación específica en un vasto "espacio conceptual" multidimensional.
Técnicamente, un *embedding* de texto es un proceso que convierte un fragmento de texto (una palabra, una oración o un documento completo) en un vector denso de números. Este vector captura el significado semántico del texto. Los documentos con significados similares tendrán vectores que están "cerca" entre sí en este espacio.
Cuando tienes una consulta, el modelo de *embedding* convierte tu pregunta en un vector y luego busca en la biblioteca los vectores de documentos que están más cerca de él. Esta búsqueda inicial es increíblemente eficiente y recupera un amplio conjunto de documentos potencialmente relevantes.
2. El Consultor Experto: El Modelo Reranker
La recuperación inicial del modelo de *embedding* es rápida, pero no siempre es perfecta. Podría traer documentos que están temáticamente relacionados pero que no responden con precisión a la consulta del usuario. Aquí es donde entra el *reranker*.
Si el modelo de *embedding* es un bibliotecario generalista, el *reranker* es un experto en la materia. Toma los mejores resultados de la búsqueda inicial y realiza un análisis más matizado y computacionalmente intensivo. En lugar de comparar un vector de consulta con vectores de documentos de forma independiente, un modelo *reranker* (típicamente un codificador cruzado) mira la consulta y cada documento como un par.
Esta comparación directa permite al *reranker* calcular una puntuación de relevancia mucho más precisa. Luego reordena los documentos basándose en esta puntuación, empujando los resultados más relevantes a la parte superior. Este proceso de dos etapas —una recuperación inicial rápida seguida de un *reranking* preciso— es el secreto del rendimiento de vanguardia de RAG.
Conoce los Modelos Qwen3: Un Nuevo Estándar en IA de Código Abierto
La serie Qwen3 de Alibaba Cloud no es solo otro conjunto de modelos; representa un avance significativo en el PNL de código abierto. Esto es lo que hace que los modelos de *embedding* y *reranker* destaquen:
- Rendimiento de Vanguardia: El modelo Qwen3-Embedding-8B, en el momento de su lanzamiento, se disparó al puesto #1 en la altamente competitiva clasificación multilingüe MTEB (Massive Text Embedding Benchmark), superando a muchos modelos establecidos.
- Capacidad Multilingüe Excepcional: Entrenados en un vasto corpus, los modelos admiten más de 100 idiomas, lo que los hace ideales para construir aplicaciones a escala global.
- Flexible y Eficiente: Los modelos vienen en varios tamaños (por ejemplo, 0.6B, 4B y 8B parámetros), lo que permite a los desarrolladores elegir el mejor equilibrio entre rendimiento, velocidad y requisitos de hardware. También admiten varios niveles de cuantificación, lo que reduce aún más su huella de memoria con un impacto mínimo en la precisión.
- Consciente de Instrucciones: Puedes proporcionar instrucciones personalizadas a los modelos para adaptar su rendimiento a tareas o dominios específicos, una característica que puede generar ganancias significativas de rendimiento.
Configurando Tu Entorno de IA Local
Ahora, manos a la obra. El primer paso es configurar Ollama y descargar los modelos Qwen3.
Paso 1: Instalar Ollama
Ollama proporciona un comando de instalación simple de una sola línea para macOS y Linux. Abre tu terminal y ejecuta:
curl -fsSL https://ollama.com/install.sh | sh
Para Windows, descarga el instalador oficial desde el sitio web de Ollama.
Una vez instalado, puedes verificar que funciona ejecutando:
ollama --version
Paso 2: Descargar los Modelos Qwen3
Con Ollama en funcionamiento, puedes extraer modelos de la biblioteca de Ollama. Los modelos Qwen3 están alojados bajo el espacio de nombres dengcao. Descargaremos una versión recomendada de los modelos de *embedding* y *reranker*. La etiqueta :Q5_K_M significa un nivel de cuantificación específico que ofrece un gran equilibrio entre rendimiento y uso de recursos.
En tu terminal, ejecuta los siguientes comandos:
# Descargar el modelo de embedding de 8B parámetros
ollama pull dengcao/Qwen3-Embedding-8B:Q5_K_M
# Descargar el modelo reranker de 4B parámetros
ollama pull dengcao/Qwen3-Reranker-4B:Q5_K_M
Estas descargas pueden tardar algún tiempo, dependiendo de tu conexión a internet. Una vez completadas, puedes ver tus modelos disponibles localmente ejecutando ollama list.
Parte 1: Generando Embeddings con Qwen3
Con el modelo de *embedding* descargado, generemos algunos vectores. Usaremos la librería oficial de Python ollama. Si no la tienes instalada, ejecuta pip install ollama.
Aquí tienes un script simple de Python para generar un *embedding* para un fragmento de texto:
import ollama
# Define el nombre del modelo como fue descargado
EMBEDDING_MODEL = 'dengcao/Qwen3-Embedding-8B:Q5_K_M'
def get_embedding(text: str):
"""Generates an embedding for a given text."""
try:
response = ollama.embeddings(
model=EMBEDDING_MODEL,
prompt=text
)
return response['embedding']
except Exception as e:
print(f"An error occurred: {e}")
return None
# --- Ejemplo de Uso ---
sentence = "Ollama makes it easy to run LLMs locally."
embedding = get_embedding(sentence)
if embedding:
print(f"Embedding for: '{sentence}'")
# Imprime las primeras dimensiones para brevedad
print(f"First 5 dimensions: {embedding[:5]}")
print(f"Total dimensions: {len(embedding)}")
Este script mostrará los primeros cinco valores del vector generado y su tamaño total (que es 4096 para el modelo de 8B). Este vector es la representación numérica de nuestra oración, lista para ser almacenada y comparada.
Parte 2: Refinando Resultados con el Reranker Qwen3
Usar el *reranker* es ligeramente diferente. En lugar de un *endpoint* rerank dedicado, usamos el *endpoint* estándar chat. Creamos un *prompt* específico que le pide al modelo que actúe como un *reranker*, tomando una consulta y un documento como entrada y produciendo una puntuación de relevancia.
Creemos una función Python para manejar esto. Le pediremos al modelo que devuelva un simple "Sí" o "No" para indicar la relevancia, lo que podemos convertir fácilmente en una puntuación.
import ollama
# Define el nombre del modelo como fue descargado
RERANKER_MODEL = 'dengcao/Qwen3-Reranker-4B:Q5_K_M'
def rerank_document(query: str, document: str) -> float:
"""
Uses the Qwen3 Reranker to score the relevance of a document to a query.
Returns a score of 1.0 for 'Yes' and 0.0 for 'No'.
"""
prompt = f"""
Eres un experto evaluador de relevancia. Tu tarea es evaluar si el
siguiente documento es relevante para la consulta del usuario.
Por favor, responde con un simple 'Sí' o 'No'.
Consulta: {query}
Documento: {document}
"""
try:
response = ollama.chat(
model=RERANKER_MODEL,
messages=[{'role': 'user', 'content': prompt}],
options={'temperature': 0.0} # Para salida determinista
)
answer = response['message']['content'].strip().lower()
if 'yes' in answer:
return 1.0
return 0.0
except Exception as e:
print(f"An error occurred during reranking: {e}")
return 0.0
# --- Ejemplo de Uso ---
user_query = "How do I run models locally?"
doc1 = "Ollama is a tool for running large language models on your own computer."
doc2 = "The capital of France is Paris."
score1 = rerank_document(user_query, doc1)
score2 = rerank_document(user_query, doc2)
print(f"Relevancia del Doc 1: {'Relevante' if score1 > 0.5 else 'No Relevante'} (Puntuación: {score1})")
print(f"Relevancia del Doc 2: {'Relevante' if score2 > 0.5 else 'No Relevante'} (Puntuación: {score2})")
Esta función demuestra cómo interactuar con el *reranker*. Identifica correctamente que doc1 es altamente relevante para la consulta, mientras que doc2 no lo es.
Juntándolo Todo: Una Implementación Simple de RAG
Ahora, el evento principal. Construyamos un mini-pipeline RAG que utilice ambos modelos para responder a una consulta de una pequeña base de conocimientos. Para la búsqueda de similitud, usaremos numpy. Instálalo con pip install numpy.
import ollama
import numpy as np
# --- Definiciones de Modelo ---
EMBEDDING_MODEL = 'dengcao/Qwen3-Embedding-8B:Q5_K_M'
RERANKER_MODEL = 'dengcao/Qwen3-Reranker-4B:Q5_K_M'
# --- 1. Corpus y Generación de Embedding Offline ---
documents = [
"The Qwen3 series of models was developed by Alibaba Cloud.",
"Ollama provides a simple command-line interface for running LLMs.",
"A reranker model refines search results by calculating a precise relevance score.",
"To install Ollama on Linux, you can use a curl command.",
"Embedding models convert text into numerical vectors for semantic search.",
]
# En una aplicación real, almacenarías estos embeddings en una base de datos vectorial
corpus_embeddings = []
print("Generando embeddings para el corpus de documentos...")
for doc in documents:
response = ollama.embeddings(model=EMBEDDING_MODEL, prompt=doc)
corpus_embeddings.append(response['embedding'])
print("Embeddings generados.")
def cosine_similarity(v1, v2):
"""Calcula la similitud del coseno entre dos vectores."""
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
# --- 2. Recuperación Online y Reranking ---
user_query = "How do I install Ollama?"
# Incrustar la consulta del usuario
query_embedding = ollama.embeddings(model=EMBEDDING_MODEL, prompt=user_query)['embedding']
# Realizar recuperación inicial (búsqueda semántica)
retrieval_scores = [cosine_similarity(query_embedding, emb) for emb in corpus_embeddings]
top_k_indices = np.argsort(retrieval_scores)[::-1][:3] # Obtener los 3 mejores resultados
print("\n--- Resultados de Recuperación Inicial (antes del reranking) ---")
for i in top_k_indices:
print(f"Puntuación: {retrieval_scores[i]:.4f} - Documento: {documents[i]}")
# --- 3. Rerankear los mejores resultados ---
retrieved_docs = [documents[i] for i in top_k_indices]
print("\n--- Rerankeando los mejores resultados ---")
reranked_scores = [rerank_document(user_query, doc) for doc in retrieved_docs]
# Combinar documentos con sus nuevas puntuaciones y ordenar
reranked_results = sorted(zip(retrieved_docs, reranked_scores), key=lambda x: x[1], reverse=True)
print("\n--- Resultados Finales (después del reranking) ---")
for doc, score in reranked_results:
print(f"Puntuación de Relevancia: {score:.2f} - Documento: {doc}")
Cuando ejecutes este script, verás el poder del proceso de dos etapas. La recuperación inicial encuentra correctamente documentos relacionados con "Ollama" y "instalación". Sin embargo, el *reranker* identifica con precisión el documento sobre el uso de curl como el más relevante, empujándolo a la cima con una puntuación perfecta.
Conclusión
Ahora has configurado y utilizado con éxito uno de los tándems de IA de código abierto más potentes disponibles hoy en día, directamente en tu máquina local. Al combinar el amplio alcance del modelo de *embedding* Qwen3 con la aguda precisión del *reranker* Qwen3, puedes construir aplicaciones que comprenden y procesan el lenguaje con un nivel de matiz que antes era dominio exclusivo de grandes sistemas propietarios.
El viaje no termina aquí. Puedes experimentar con diferentes tamaños de modelo, probar varios niveles de cuantificación e integrar este pipeline en aplicaciones más complejas. La capacidad de ejecutar estas herramientas localmente abre un mundo de posibilidades, permitiéndote crear, innovar y explorar sin comprometer la privacidad o el rendimiento. Bienvenido a la nueva era de la IA local y de código abierto.
¿Quieres una plataforma integrada y todo en uno para que tu equipo de desarrolladores trabaje junto con la máxima productividad?
¡Apidog cumple con todas tus demandas y reemplaza a Postman a un precio mucho más asequible!