Cómo añadir memoria a tu agente con Weaviate (Paso a Paso)

Weaviate Agregar Memoria a Tu Agente: Un Tutorial Directo de 2500 Palabras

Si quieres que tu agente inteligente realmente recuerde el contexto entre conversaciones, necesitas weaviate agregar memoria a tu agente de la manera correcta, usando búsqueda vectorial para almacenar y recordar interacciones previas. No estamos simplemente echando fragmentos en alguna base de datos; estamos construyendo un gráfico de conocimiento real enriquecido con búsqueda semántica que mantiene a tu agente afilado.

Lo Que Estás Construyendo y Por Qué Es Importante

Estamos construyendo un agente que utiliza Weaviate para almacenamiento de memoria, de modo que pueda tener conversaciones significativas y dinámicas, no solo preguntas y respuestas sin estado. Olvida esas demostraciones superficiales de chatbots que reinician cada pregunta: esto se trata de una persistencia contextual que tus usuarios realmente sentirán.

Requisitos Previos

• Python 3.11+
• Weaviate Community Edition (última versión estable, usé 1.19.0)
• Paquetes de pip: weaviate-client>=4.16.0, requests, dotenv
• Clave API de OpenAI o cualquier otra clave API de modelo de incrustación (GPT-4, Cohere o Huggingface)
• Docker instalado (opcional pero recomendado para ejecutar Weaviate localmente)
• Comprensión básica de bases de datos vectoriales y generación de incrustaciones

Estadísticas Rápidas sobre Weaviate

Métrica	Valor
Estrellas en GitHub	15,839
Forks	1,227
Issues Abiertos	582 (a partir del 20 de marzo de 2026)
Licencia	BSD-3-Clause
Última Actualización	20 de marzo de 2026

Estos números muestran que Weaviate es maduro pero aún activo; no estarás esperando atrapado en alguna biblioteca abandonada.

Paso a Paso: Weaviate Agregar Memoria a Tu Agente

Paso 1: Configurar el Servidor Weaviate

# Ejecutar Weaviate con Docker para pruebas locales rápidas
docker run -d \
 -p 8080:8080 \
 -e AUTH_ANONYMOUS_ACCESS_ENABLED=true \
 -e QUERY_DEFAULTS_LIMIT=20 \
 -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
 -v $(pwd)/weaviate_data:/var/lib/weaviate \
 semitechnologies/weaviate:latest

Por qué esto es importante: Weaviate soporta la persistencia y el acceso anónimo habilitados por defecto aquí, lo que facilita el desarrollo local. Configurar QUERY_DEFAULTS_LIMIT=20 previene que te encuentres con límites molestos de 10 resultados en las consultas, que molestan incluso a los desarrolladores experimentados. Recuerda, si no deseas acceso anónimo, configura claves API. Pero para pruebas, esto está bien.

Errores comunes: Si el contenedor se bloquea, verifica que el puerto 8080 esté libre. A veces Docker Desktop u otros contenedores previos lo ocupan. Además, si envías incrustaciones más rápido de lo que la persistencia de Weaviate puede manejar (raro localmente), espera retrasos.

Paso 2: Definir un Esquema para la Memoria de Tu Agente

import weaviate

client = weaviate.Client("http://localhost:8080")

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Almacena un único segmento de memoria para el agente",
 "properties": [
 {
 "name": "text",
 "dataType": ["text"],
 "description": "El contenido textual de la memoria."
 },
 {
 "name": "embedding",
 "dataType": ["number[]"],
 "description": "Representación de incrustación vectorial."
 },
 {
 "name": "timestamp",
 "dataType": ["date"],
 "description": "Cuándo se almacenó la memoria."
 }
 ],
 "vectorizer": "none" # Inyectaremos las incrustaciones nosotros mismos
 }
 ]
}

client.schema.delete_all() # Limpieza total
client.schema.create(schema)

¿Por qué sin vectorizador? El error principal que los novatos cometen es usar ciegamente los vectorizadores de texto por defecto de Weaviate. Está bien para búsquedas de texto simples, pero cuando deseas control estricto sobre tu modelo de incrustación (por ejemplo, OpenAI, Cohere), tienes que cargar los vectores tú mismo. Esto elimina la confusión de tutoriales competidores que sobreutilizan los vectorizadores A BORDO de Weaviate para agentes.

Eliminar el esquema antes crea una nueva oportunidad, lo que te protege de extraños errores de “el esquema ya existe”. Claro, borra datos, pero esto es desarrollo local.

Paso 3: Generar y Subir Incrustaciones de Memoria

import os
import requests
from datetime import datetime

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

def get_openai_embedding(text):
 resp = requests.post(
 "https://api.openai.com/v1/embeddings",
 headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
 json={"input": text, "model": "text-embedding-ada-002"}
 )
 resp.raise_for_status()
 return resp.json()["data"][0]["embedding"]

def add_memory_entry(client, text):
 embedding = get_openai_embedding(text)
 memory_obj = {
 "text": text,
 "embedding": embedding,
 "timestamp": datetime.utcnow().isoformat()
 }
 client.data_object.create(memory_obj, "MemoryEntry", vector=embedding)

# Ejemplo de uso
add_memory_entry(client, "Recuerdo que el cielo es azul.")
add_memory_entry(client, "El significado de la vida es 42.")

¿Por qué generar incrustaciones tú mismo? Porque es increíblemente valioso desacoplar la generación de incrustaciones y el almacenamiento de vectores. Podrías necesitar cambiar tu modelo de incrustación más tarde o agregar vectores de diferentes fuentes. Esos otros tutoriales mezclan todo y te atrapan.

Error común aquí: olvidar pasar la incrustación como el parámetro vector vector=embedding en la llamada a data_object.create. Si omites esto, Weaviate intentará vectorizarlo automáticamente (y fallará porque configuramos vectorizer: none).

Paso 4: Consultar Memoria con Búsqueda Semántica

def query_memory(client, question, top_k=3):
 question_embedding = get_openai_embedding(question)
 near_vector = {"vector": question_embedding}
 response = client.query.get("MemoryEntry", ["text", "timestamp"])\
 .with_near_vector(near_vector)\
 .with_limit(top_k)\
 .do()
 results = response.get("data", {}).get("Get", {}).get("MemoryEntry", [])
 return results

# Prueba
results = query_memory(client, "¿De qué color es el cielo?")
for res in results:
 print(f"Memoria: {res['text']} (almacenada en {res['timestamp']})")

¿Por qué búsqueda semántica? La búsqueda por palabras clave en memoria es inútil para agentes que deben manejar conversaciones de múltiples turnos con consultas matizadas. La verdadera magia está en la búsqueda de incrustaciones para “pensamientos similares” sin superposición exacta de palabras clave.

La característica clave es cómo mezclas y combinas estas consultas dinámicamente en tiempo de ejecución para mantener a tu agente consciente del contexto sin asfixiarse con recuerdos irrelevantes.

Paso 5: Conectar Tu Agente para Usar Memoria de Weaviate

class MemoryAgent:
 def __init__(self, weaviate_client):
 self.client = weaviate_client

 def remember(self, text):
 add_memory_entry(self.client, text)

 def recall(self, question):
 return query_memory(self.client, question, top_k=5)

 def chat(self, question):
 memories = self.recall(question)
 # Concatenación simple para el prompt—reemplaza con tu plantilla de prompt
 prompt_context = "\n".join([m["text"] for m in memories])
 prompt = f"Contexto:\n{prompt_context}\n\nPregunta: {question}\nRespuesta:"
 
 # Enviar prompt al LLM (no cubierto aquí)
 # Simular:
 return f"Respuesta simulada basada en recuerdos:\n{prompt}"

agent = MemoryAgent(client)
agent.remember("El agente fue creado el 20 de marzo de 2026.")
agent.remember("Python es el lenguaje de programación reconocido para IA.")

print(agent.chat("¿Cuándo fue creado el agente?"))

¿Por qué este diseño? Separar la gestión de la memoria de la lógica de “chat” del agente es crucial. Odié el código fuertemente acoplado donde manejar el contexto convierte tu llamada de generación en un lío anidado. Con este patrón, puedes rastrear, almacenar y recordar de manera independiente. Si deseas cambiar a un mejor LLM o añadir caché, es trivial.

Los Problemas que No Escucharás en Otros Tutoriales

1. Confusión de esquemas. Muchos tutoriales pasan por alto el diseño del esquema, pero si tu esquema está mal, tus vectores y metadatos son basura. Te arrepentirás de no planear timestamps o metadatos como IDs de usuario para filtrar tu memoria.
2. Los costos de incrustación importan. Las incrustaciones de OpenAI no son gratis. Si agregas miles de memorias, espera una factura. Agrupa tu generación para reducir costos y almacena incrustaciones de manera agresiva.
3. La expansión de memoria mata el rendimiento. ¿Consultando una base de datos vectorial con decenas de miles de entradas? Verás picos de latencia y resultados de recuerdo ruidosos. Se necesita una poda regular: una realidad dura pero inevitable.
4. Desajustes en la dimensión de los vectores. Si accidentalmente intercambias modelos de incrustación o versiones, tus vectores almacenados no coincidirán con los vectores de consulta. Obtendrás cero resultados o coincidencias engañosas. Siempre corrige la versión de tu modelo de incrustación en tu canal.
5. La consistencia de datos es un dolor. Sin soporte de transacciones, escrituras o actualizaciones parciales pueden dejar memoria colgante sin contexto. Este sutil error puede atormentarte en producción, especialmente si estás actualizando memorias.

Ejemplo Completo en Funcionamiento

import os
import requests
from datetime import datetime
import weaviate

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
WEAVIATE_URL = "http://localhost:8080"

def get_openai_embedding(text):
 r = requests.post(
 "https://api.openai.com/v1/embeddings",
 headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
 json={"input": text, "model": "text-embedding-ada-002"},
 )
 r.raise_for_status()
 return r.json()["data"][0]["embedding"]

client = weaviate.Client(WEAVIATE_URL)
client.schema.delete_all()

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Almacena la memoria del agente",
 "properties": [
 {"name": "text", "dataType": ["text"]},
 {"name": "embedding", "dataType": ["number[]"]},
 {"name": "timestamp", "dataType": ["date"]}
 ],
 "vectorizer": "none"
 }
 ]
}
client.schema.create(schema)

def add_memory(text):
 embedding = get_openai_embedding(text)
 data = {"text": text, "embedding": embedding, "timestamp": datetime.utcnow().isoformat()}
 client.data_object.create(data, "MemoryEntry", vector=embedding)

def query_memories(question, top_k=5):
 q_emb = get_openai_embedding(question)
 near_vector = {"vector": q_emb}
 res = client.query.get("MemoryEntry", ["text", "timestamp"])\
 .with_near_vector(near_vector).with_limit(top_k).do()
 return res.get("data", {}).get("Get", {}).get("MemoryEntry", [])

class Agent:
 def __init__(self, client):
 self.client = client

 def remember(self, text):
 add_memory(text)

 def chat(self, question):
 memories = query_memories(question)
 context = "\n".join([m["text"] for m in memories])
 prompt = f"Contexto:\n{context}\n\nPregunta: {question}\nRespuesta:"
 # Respuesta ficticia
 return prompt

agent = Agent(client)
agent.remember("El cielo es azul.")
agent.remember("El agua hierve a 100 grados Celsius.")
print(agent.chat("¿De qué color es el cielo?"))

¿Qué sigue?

Después de dominar la integración de memoria de Weaviate, tu próximo paso concreto es construir un pipeline de poda y actualización de memoria. Esto significa evaluar periódicamente qué memorias están obsoletas o son irrelevantes y eliminarlas o actualizarlas. Si dejas que la memoria crezca sin control, las respuestas de tu agente se ralentizarán y se volverán inconsistentes.

Considera implementar un enfoque de degradación basado en el tiempo o un ranking de importancia de la memoria para mantener tu base de datos ágil. Esto agudizará el enfoque del agente en lo que realmente importa.

Preguntas Frecuentes

¿Por qué debería desactivar el vectorizador incorporado de Weaviate?

Los vectorizadores incorporados son adecuados para demos simples, pero te restringen a su modelo de incrustación específico y dificultan las actualizaciones. Quieres inyectar tus propias incrustaciones generadas a partir de modelos como el text-embedding-ada-002 de OpenAI, para que tú controles la calidad del vector y los costos de la API.

¿Qué hago si mis consultas no devuelven resultados?

Primero, confirma que las dimensiones de tus incrustaciones coincidan. Las incrustaciones ada-002 de OpenAI son vectores de 1536 dimensiones. Si tus vectores almacenados y tus vectores de consulta difieren en dimensión, la búsqueda de similitud no devuelve nada. También verifica que el vectorizador de tu esquema esté configurado como ‘none’ y que envíes explícitamente tus propios vectores al crear objetos.

¿Cómo gestiono los costos de incrustación con miles de entradas de memoria?

Incrusta tus datos por lotes en lugar de hacer llamadas únicas y almacena las incrustaciones en disco o Redis. El preprocesamiento de nueva información fuera de línea también puede ayudar. Además, sé estratégico en lo que almacenas: guarda resúmenes, no conversaciones completas. Por último, explora modelos de código abierto más baratos, pero ten cuidado con la precisión.

Recomendaciones para Personas Desarrolladoras

Tipo de Desarrollador	Próximos Pasos Recomendados
Investigador de IA	Integra Weaviate con incrustaciones de transformadores personalizadas y explora búsquedas híbridas que combinan similitud de texto y vector.
Ingeniero Backend	Implementa gestión del ciclo de vida de la memoria con poda automatizada, reconstrucción de índices y monitoreo de durabilidad.
Desarrollador Full-Stack	Crea un panel de UI para visualizar y gestionar entradas de memoria, y conecta la memoria de Weaviate con tu interfaz de chat frontend.

Datos a partir del 21 de marzo de 2026. Fuentes: https://github.com/weaviate/weaviate, https://weaviate.io/product/integrations/mem0

Artículos Relacionados

• Aumenta los LLMs con Gráficas de Conocimiento Confiables: La Innovación de Qinggang Zhang
• Desbloquea tu Marca: Creando el Logo Perfecto de una Red Neuronal Convolucional
• Por Qué Usar Arquitectura de Agente de IA

🕒 Published: March 26, 2026