Hosting en producción: Supabase y pgvector
De una carpeta local a Supabase + pgvector: managed frente a self-hosted, el paso a paso y la operación.
Todo lo que has construido hasta ahora vive en una carpeta. persist_directory="./chroma_db/" es una postura de desarrollo: un proceso, un disco, sin concurrencia, sin copias de seguridad, sin control de acceso y con un corpus que se evapora en cuanto haces docker build sin un volumen. El curso marca la transición con una frase:
«Bueno, ya lo has construido en local. Ahora, vamos a desplegarlo.» 03:33:18
Esta parte es ese paso. Responde a tres preguntas por orden: ¿el Postgres de quién compro?, ¿cómo llevo a él exactamente el pipeline que ya tengo? y ¿qué he asumido a nivel operativo que no tenía cuando el store era una carpeta?. La columna vertebral práctica es el recorrido por Supabase del curso en 03:36:00–03:54:27.
En términos del modelo mental de la Parte 1, esta parte toca exactamente una caja — el Store + Index de la Fase A — y no toca ninguna otra. Los loaders, el splitter, el embedding model, el retriever, el prompt y la chain no cambian. Lo que cambia es la dirección física de los vectores y, de forma menos evidente, el tercer presupuesto: el dinero deja de ser una factura de API y pasa a ser una partida mensual, más el egress, más tu tiempo.
La afirmación en una línea, y por qué solo es verdad a medias
La afirmación pedagógica central del capítulo de Supabase es que pasar a producción cambia exactamente una línea de Python:
«Exactamente lo mismo que teníamos en local… ahora lo tenemos en algún sitio de la nube al que nos podemos conectar.» 03:52:22
A nivel del código de retrieval esto es cierto de verdad, y lo es gracias a una decisión de diseño que heredaste gratis: la interfaz VectorStore de LangChain es una costura real. El constructor de Chroma y el de PGVector reciben kwargs distintos pero exponen la misma superficie add_documents / similarity_search / similarity_search_with_score / as_retriever, así que a todo consumidor posterior al store le da igual cuál tenga detrás.
Este es el «antes» — código local real y publicado:
# /home/oriol/lab/rag/code/production-course-main-code/vector_stores.py (persist_chroma)
def persist_chroma():
persist_dir = "./chroma_db/"
vectorstore = Chroma.from_documents(
documents=SAMPLE_DOCS,
embedding=embeddings_model,
persist_directory=persist_dir,
)
original_count = vectorstore._collection.count()
print(f"Persisted vector store with {original_count} documents.")
print(f"Vector store persisted at: {persist_dir}")
# simulate restart - load from disk
del vectorstore
reloaded = Chroma(
embedding_function=embeddings_model,
persist_directory=persist_dir,
)
Y el «después» tiene la misma forma, con un DSN donde estaba el directorio. El paquete de integración es langchain-postgres (uv add langchain-postgres), que trae SQLAlchemy 2, los bindings de Python de pgvector y psycopg 3 — no psycopg2, lo cual importa en un momento. Fíjate bien en la ruta del import: es langchain_postgres, no langchain_community, exactamente como aparece en pantalla en 03:42:35. Es la misma trampa de instalación que langchain-chroma frente a langchain-community en la Parte 2, y produce los mismos errores confusos con pinta de deprecación cuando te equivocas.
# The production swap. Same interface, different engine.
from langchain_postgres import PGVector # NOT langchain_community
vectorstore = PGVector(
embeddings=embeddings_model, # note: `embeddings=`, not `embedding=`
collection_name="production_docs",
connection=DATABASE_URL, # postgresql+psycopg://postgres:...@db.<ref>.supabase.co:5432/postgres
embedding_length=1536, # text-embedding-3-small; without it you cannot index
use_jsonb=True,
)
Tres de esos cinco argumentos son trampas, y el curso solo habla de una.
| Concepto | Chroma | PGVector |
|---|---|---|
| Kwarg de embeddings | embedding= (y embedding_function= al reabrir) | embeddings= |
| Dónde viven los datos | persist_directory= | connection= (una cadena DSN o un Engine de SQLAlchemy) |
| Partición lógica | collection_name → una colección real de Chroma | collection_name → una fila en langchain_pg_collection |
| Almacenamiento de metadatos | implícito | use_jsonb=True |
| Dimensión del vector | inferida, invisible | embedding_length= — se omite por defecto, y entonces no se puede indexar nada |
Así que la afirmación sobre el código se sostiene. Lo que no se sostiene es la implicación de que, por tanto, la migración sale gratis. Entre el constructor y un sistema delante del que pondrías a un usuario, has adquirido: row-level security que tienes que activar a mano, una decisión de connection pooling que el curso se salta explícitamente, un índice ANN que nadie ha creado por ti, un límite de almacenamiento medido en megabytes, un límite de egress y un viaje de ida y vuelta por la red donde antes había una lectura de la page cache. Eso es el resto de esta parte.
Managed o self-hosted: el intercambio que estás haciendo de verdad
La Parte 8 ajustó el índice y la Parte 9 le puso precio. La versión corta que necesitas aquí, para que la comparación de proveedores tenga un marco: las franjas de escala de la fuente sitúan menos de 100K vectores en Chroma local, 100K–1M en Pinecone serverless, 1M–10M en pgvector managed y más de 10M en pgvector self-hosted 03:31:53. Las tres opciones de hosting de esta parte son los proveedores concretos de esa franja de pgvector managed — que es donde empieza casi todo sistema real y donde se queda la mayoría.
El invariante 5 — cada capa es un «elige 2» — aparece aquí como dinero / carga de ops / control:
| Managed (Supabase, Neon, RDS) | Postgres + pgvector self-hosted | |
|---|---|---|
| Carga de ops | Casi cero — sin parches, sin pg_upgrade, sin cron de copias de seguridad, sin montar la replicación | «Muy significativa» 03:21:10 |
| Coste con 500K vectores | ~$35/mes | ~$20/mes, más tus horas |
| Coste con 5M / 50M vectores | ~$100 / ~$400 al mes | ~$75 / ~$300 al mes |
| Control | Limitado — tienes los mandos que expone el proveedor | Total |
| Responsabilidad de los fallos | La guardia del proveedor | Tuya |
Esas cifras son el gráfico de divergencia de la Parte 9 03:24:59–03:26:20. Lee la forma, no los dígitos: el sobreprecio de managed ronda los $15/mes con 500K y los $100/mes con 50M — un error de redondeo al lado de un solo día de ingeniero al mes administrando Postgres. La brecha que sí explota en ese gráfico es Pinecone frente a pgvector (más de $1,500 frente a $300 con 50M), no pgvector managed frente a self-hosted.
La postura del instructor, heredada del capítulo de costes, no deja lugar a dudas: empieza con managed. El tiempo que ahorras vale más que la diferencia de precio, y puedes cambiar más adelante precisamente porque pgvector es la misma extensión en ambos mundos.
«Nos centramos sobre todo en pgvector porque es open source, es fácil de añadir como extensión a una base de datos Postgres, y funciona.» 03:52:22
Esa frase es todo el argumento estratégico. pgvector no es una nueva superficie operativa. Es un tipo de columna en una base de datos que tu organización ya sabe respaldar, replicar, monitorizar, gestionar con permisos y restaurar. Una base de datos vectorial dedicada es un segundo sistema con estado, con una segunda estrategia de copias de seguridad, un segundo modelo de autenticación y un segundo runbook de guardia. Las tres opciones de hosting de abajo son, todas ellas, un Postgres managed — ninguna base de datos vectorial dedicada sobrevive a la preselección, y esa es la tesis que se defiende por omisión.
Los tres caminos a producción
La fuente reduce el mercado a tres, y es honesta en que se trata de una preselección de mercado y no del resultado de un benchmark:
«Por supuesto, hay más, pero me quedo con los tres más demandados.» 03:33:18
El criterio de selección que se enuncia es la demanda, no la superioridad técnica. Railway, Fly.io, Render, Crunchy Bridge, Timescale/Tiger, DigitalOcean Managed Postgres, Cloud SQL, AlloyDB y un simple Postgres self-hosted en Docker existen todos, todos ejecutan pgvector, y ninguno se evaluó y se descartó — simplemente no estaban en la diapositiva.
| Supabase | Neon | AWS RDS | |
|---|---|---|---|
| Etiqueta en la diapositiva | ★ Recomendado | 🏷 Serverless | 🏷 Enterprise |
| Precio destacado en la diapositiva | $25/mes | $19/mes | $60/mes |
| Plan gratuito | $0, base de datos de 500 MB | $0, 512 MB de almacenamiento | sin plan gratuito permanente |
| Primer plan de pago | Pro $25/mes, base de datos de ~8 GB | Pro ~$19/mes | pequeño ~$30/mes, gama media ~$60/mes |
| Plan mayor | Team ~$599/mes | — | escala dentro del catálogo del hiperescalador |
| pgvector | incluido, en todos los planes | incluido | soportado en el motor Postgres |
| Diferenciador | la mejor relación calidad-precio; un plan gratuito realmente gratuito; auth + REST + almacenamiento en el mismo producto | scale to zero — dejas de pagar por cómputo ocioso | completitud: Multi-AZ, PITR, IAM, VPC, réplicas de lectura |
| Quién lo elige | por defecto; cualquier carga estable | cargas variables / a ráfagas / con mucho tiempo ocioso | equipos que ya están dentro de AWS |
Una fila de esa tabla es ruido y deberías ignorarla: los planes gratuitos empatan. Los 500 MB de Supabase y los 512 MB de Neon se diferencian en 12 MB — un 2.4%, y 512 MB no es más que 0.5 GiB expresado con exactitud frente a una cifra redonda de marketing. Ahí no se decide nada.
Los precios son los impresos en la diapositiva y los dichos en 03:33:18–03:35:20. El propio instructor los matiza — «unos 8 GB», «en el momento de grabar este vídeo» — y el vídeo se publicó el 2026-05-26. Trátalos como la forma del mercado, no como presupuestos. Las páginas de precios de los proveedores son la única fuente de verdad de lo que vas a pagar realmente.
Tres correcciones a la fuente, dichas claramente en lugar de maquilladas:
- El plan Team de Supabase cuesta $599/mes, no 5.99. Los subtítulos automáticos lo muestran como «$5.99» tanto en el capítulo 17 03:34:19 como en el capítulo 18 03:37:00 — la misma cifra dicha dos veces, con un punto decimal perdido. Un plan para equipos más barato que el plan Pro de $25 es imposible. Escribe $599.
- El instructor da los precios de AWS RDS de forma incoherente. En 03:34:19 el «punto de partida son $60 al mes»; en 03:35:20, «la instancia de gama media… ronda los $60 al mes y la pequeña unos $30 al mes». La lectura coherente es ~$30 la pequeña / ~$60 la de gama media, con la diapositiva destacando la de gama media. Fíjate además en que la cifra independiente del capítulo de costes — pgvector en RDS ≈ $32/mes con 500K vectores 03:23:35 — coincide con la lectura «pequeña ≈ $30», lo que es una buena corroboración.
- «Equipos que ya están en AWS o en Google Cloud Platform» 03:35:20 es impreciso: RDS es solo de AWS. La generalización correcta es quédate dentro de la nube que ya usa tu organización; en GCP, los análogos son Cloud SQL for PostgreSQL y AlloyDB, y ambos soportan pgvector.
El procedimiento de decisión, lo bastante corto como para memorizarlo:
- Por defecto, Supabase. Plan gratuito para aprender y prototipar; Pro de $25 cuando se te queden cortos los 500 MB.
- Elige Neon en su lugar si tu carga es variable o pasa mucho tiempo ociosa y puedes asumir un arranque en frío.
- Elige RDS (o Cloud SQL / AlloyDB) si tu equipo ya vive en ese hiperescalador. El factor decisivo es tu perímetro, no el precio.
- Rehaz las cuentas con tus propias cifras antes de aceptar la opción por defecto — la recomendación es un punto de partida, no una ley.
- Comprueba que pgvector está disponible en el plan que elijas. Los tres lo incluyen. Un cuarto proveedor podría no hacerlo.
- Aprende en el plan gratuito; sube de plan ante un límite medido — almacenamiento, conexiones o egress —, no por una sensación.
Esto último es una promesa que el curso cumple: todos los capítulos prácticos que quedan están diseñados para caber dentro de Supabase Free, y el instructor lo dice — «no vas a tener que gastar ni un céntimo» 03:35:20.
Supabase, en concreto
Supabase se describe a sí misma como «la plataforma de desarrollo Postgres» — constrúyelo en un fin de semana, escala a millones — y el paquete incluye: una base de datos Postgres, autenticación, APIs autogeneradas al instante, Edge Functions, suscripciones realtime, almacenamiento de ficheros y embeddings vectoriales 03:36:00. Esa última viñeta es pgvector. No estás adoptando una base de datos vectorial nueva; estás moviendo la misma extensión de tu portátil al Postgres managed de otro.
Ese paquete es la mayor parte de la razón de que se lleve la recomendación. Una aplicación RAG real normalmente necesita también auth, una capa de API y algún sitio donde guardar los PDFs de origen. Si de otro modo tendrías que comprarle esas piezas a tres proveedores, la comparación de los $25 no es $25 frente a $19.
El plan gratuito, completo (03:36:00–03:37:00, leído de la página de precios):
| Concepto del plan gratuito | Valor |
|---|---|
| Precio | $0/mes |
| Tamaño de la base de datos | 500 MB (línea secundaria de la tarjeta: Shared CPU • 500 MB RAM) |
| Peticiones a la API | Ilimitadas |
| Usuarios activos mensuales | 50,000 |
| Egress | 5 GB |
| Egress cacheado | 5 GB |
| Almacenamiento de ficheros | 1 GB |
| Soporte | Comunidad |
Escalones de pago: Pro $25/mes (con la etiqueta «most popular», base de datos de ~8 GB), Team $599/mes.
El recorrido, de principio a fin
El recurso didáctico que usa aquí el curso es la repetición deliberada sobre un backend distinto — los mismos documentos, el mismo embedding model, la misma búsqueda por similitud, un store nuevo:
«…hacer exactamente lo que hemos hecho antes. Así ves la foto completa.» 03:35:20
Vale la pena copiarlo cuando migres de verdad. Vuelve a ejecutar una carga de trabajo cuyas respuestas ya conoces, de modo que cualquier cosa que cambie sea atribuible al store y a nada más.
Lo que sigue es la secuencia 03:36:00–03:54:27, reorganizada para que las dos decisiones de seguridad queden juntas en lugar de a quince minutos de distancia.
Paso 1 — Crea la organización y el proyecto
- supabase.com → Pricing → lee la tarjeta Free → Start for free → inicia sesión.
- Crea primero una organización — las organizaciones agrupan proyectos. Ponle nombre (el curso usa
VectorCourse), tipo Personal, plan $0/month. - Nuevo proyecto. Un proyecto es «su propia instancia dedicada»: ponle nombre y ocúpate de las tres cosas de abajo. Cuando termina el aprovisionamiento, llegas a la rama
main, con la insigniaPRODUCTION.
La contraseña de la base de datos. El formulario tiene un botón Generate a password. Cópiala antes de hacer clic en cualquier otra cosa. Se muestra una sola vez y no se puede recuperar — solo restablecer. Se convierte en el hueco [PASSWORD] de todas las cadenas de conexión que vayas a pegar.
«Voy a copiar esta contraseña porque de verdad vais a necesitarla más adelante.» 03:38:02
¿La has perdido? Database → Settings → Reset database password → Generate → Reset. Generar un valor nuevo no basta; tienes que hacer clic en Reset para que surta efecto 03:43:06, y luego actualizar .env.
La región. El formulario dice que elijas la región más cercana a tus usuarios. El curso elige East US (North Virginia) us-east-1, que lleva una insignia RECOMMENDED; la lista de América que aparece en pantalla muestra también us-west-1 (N. California), us-west-2 (Oregón), us-east-2 (Ohio), ca-central-1 y eu-west-1 en Europa.
Afina ese consejo un paso más: elige según dónde se ejecuta tu servidor de aplicación, no según dónde estás tú o tus usuarios. Un usuario hace un viaje de ida y vuelta a tu app; tu app hace varios a la base de datos por request (leer la fila de la colección, ejecutar la búsqueda ANN, traer el texto de los chunks), y cada uno se multiplica por cada retry y cada query extra. Pon la app y la base de datos en el mismo sitio y luego preocúpate del usuario. Además, la región es en la práctica permanente — Supabase no permite mover la región en caliente, así que cambiarla significa un proyecto nuevo y una reingesta completa.
(Ruido de la fuente, señalado: en 03:38:02 los subtítulos ponen en boca del instructor «West North Carolina» como región alternativa. No existe ninguna región de Supabase con ese nombre. Trátalo como un lapsus o un artefacto de los subtítulos; solo us-east-1 se confirma en pantalla.)
Los dos interruptores de seguridad — lee esto antes de hacer clic en Create. El formulario de nuevo proyecto tiene:
- Enable Data API — marcado por defecto. «Autogenera una API RESTful para tu esquema public», que es lo que hace que
supabase-jsfuncione desde un navegador. - Enable automatic RLS — desmarcado por defecto. Crea un event trigger que activa Row Level Security en cada tabla nueva del esquema
public.
Paso 2 — Recoge las credenciales
Haz clic en Connect en la barra superior. El modal ofrece cuatro pestañas, y no son intercambiables 03:39:02:
| Pestaña | Qué te da | Úsala cuando |
|---|---|---|
| Framework | fragmentos de librerías cliente (supabase-js, etc.) | llamas a Supabase desde el código de la app a través de la Data API |
| Direct | una cadena de conexión de Postgres en bruto | esta es la que quieres — LangChain habla Postgres |
| ORM | configuración al estilo Prisma/Drizzle | tu app ya tiene un ORM |
| MCP | conectar un agente al proyecto | herramientas para agentes |
Dentro de Direct hay tres métodos de conexión, y elegir mal es un incidente de producción, no un error de sintaxis. Los textos del propio Supabase los asocian al tiempo de vida del proceso:
| Método | Cómo lo presenta el proveedor | Elígelo para |
|---|---|---|
| Direct connection | conexiones persistentes y de larga duración | un servicio FastAPI/uvicorn de larga duración, un worker, una VM, «contenedores de larga vida» |
| Transaction pooler | llamadores sin estado, cada interacción «breve y aislada» | Lambda, funciones de Vercel/Cloudflare, cualquier cosa que arranque en frío en cada request |
| Session pooler | una alternativa a la directa «al conectar a través de una red IPv4» | tu red o tu plataforma no llega al host directo, que es solo IPv6 |
El selector Type cambia la misma información entre el formato URI y el PSQL. Vale la pena entender los cinco datos en lugar de memorizar el churro 03:40:02:
| Pieza | Valor |
|---|---|
| base de datos | postgres |
| usuario | postgres |
| puerto | 5432 — «el puerto es muy importante» |
| host | db.<project-ref>.supabase.co |
| contraseña | la que guardaste al crear el proyecto |
El project ref es el subdominio aleatorio que identifica tu instancia — el del curso es yynnyoubueyfbvgnpzpq; el tuyo será otro. Aparece en el host y en todas las URLs del panel. Ya que estás aquí, copia también la Project URL y la publishable key — no hacen falta para el camino de pgvector, pero sí en cuanto toques la Data API.
Paso 3 — Activa la extensión vector
Database → Extensions → busca vector → activa el interruptor → diálogo «Enable vector» → deja el esquema extensions (DEFAULT) → Enable extension 03:41:02.
Dos cosas hacen que este paso sea casi redundante, y una hace que valga la pena hacerlo de todos modos. Supabase trae pgvector preinstalado — el propio fichero fuente del instructor lleva el comentario # Note: Supabase has pgvector pre-installed — y PGVector viene con create_extension=True por defecto, así que la propia librería lanza CREATE EXTENSION IF NOT EXISTS vector (protegido por un advisory lock de Postgres) al construirse. Hazlo igualmente: deja la dependencia visible en el panel, y es la diferencia entre «en mi proyecto funciona» y un paso de configuración documentado que otra persona puede reproducir. También importa el día en que tu aplicación se conecte con un rol restringido o de solo lectura sin permiso para crear extensiones — entonces la activas aquí una vez, a mano, y pasas create_extension=False en el código.
El equivalente en SQL, si prefieres el SQL Editor:
-- Equivalent of the Extensions-page toggle.
CREATE EXTENSION IF NOT EXISTS vector WITH SCHEMA extensions;
-- Verify:
SELECT extname, extversion FROM pg_extension WHERE extname = 'vector';
Antes de ejecutar ningún código, mira Database → Schema Visualizer: dice «No tables in schema.» Recuérdalo. Es lo que permite leer las dos tablas que aparecen en el Paso 6 como algo que ha construido LangChain y no como algo que siempre estuvo ahí.
Hay dos puertas para entrar al esquema y el curso elige deliberadamente la segunda: el SQL Editor (pegar CREATE EXTENSION / CREATE TABLE a mano) y el código de tu aplicación (PGVector(...) crea lo que necesita). «De hecho podemos ir al SQL editor y empezar a ejecutar esos comandos… Pero lo estamos haciendo todo en código.» 03:50:17
Paso 4 — Lleva el DSN a .env
# .env — never commit this file
SUPABASE_DATABASE_URL=postgresql://postgres:YOUR_REAL_PASSWORD@db.yynnyoubueyfbvgnpzpq.supabase.co:5432/postgres
OPENAI_API_KEY=sk-...
Paso 5 — Conéctate desde el código y haz un smoke test
El fichero del curso es pg_vector_section/6-supabase/01_supabase_connection.py.
# RECONSTRUCTED from screen frames at [03:42:35]-[03:45:40]
# pg_vector_section/6-supabase/01_supabase_connection.py
import os
from dotenv import load_dotenv
from langchain_postgres import PGVector # note: langchain_postgres, NOT langchain_community
from langchain_openai import OpenAIEmbeddings
load_dotenv()
# Supabase connection string format:
# postgresql://postgres:[PASSWORD]@db.[PROJECT-REF].supabase.co:5432/postgres
SUPABASE_URL = os.getenv("SUPABASE_DATABASE_URL")
# For demo, use local if Supabase not configured
DATABASE_URL = SUPABASE_URL or os.getenv(
"DATABASE_URL", "postgresql://postgres:postgres@localhost:5432/postgres"
)
def connect_to_supabase():
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
# Note: Supabase has pgvector pre-installed
vectorstore = PGVector(
embeddings=embeddings,
collection_name="production_docs",
connection=DATABASE_URL,
use_jsonb=True,
)
return vectorstore
Hay dos detalles ahí que vale la pena robar tal cual, y uno que vale la pena arreglar.
SUPABASE_URL or DATABASE_URL es un patrón realmente reutilizable 03:44:07. El mismo script se ejecuta contra un Postgres en el portátil sin cuenta en la nube y contra producción sin tocar nada. Te da un objetivo local para tests de integración que es el mismo motor que producción — algo que una división Chroma-en-local / pgvector-en-producción nunca puede darte.
use_jsonb=True no es decoración 03:44:07, 03:48:13. Guarda los metadatos del documento como JSONB de Postgres — una forma binaria ya parseada que admite operadores de contención e índices GIN — en lugar de json plano, que se guarda como texto y se vuelve a parsear en cada predicado. Eso es lo que permite que los filtros de metadatos (search_kwargs["filter"]) los evalúe la base de datos y no la fuerza bruta. El filtrado por metadatos era la lección de la Parte 4 de que la proximidad semántica no es corrección temática; use_jsonb=True es el interruptor que mantiene esa lección asequible en Postgres. Aparece en todas las llamadas PGVector(...) del capítulo. Sigue escribiéndolo — aunque ten en cuenta que en el langchain-postgres actual el argumento se ha vuelto residual: pasar use_jsonb=False ahora lanza NotImplementedError, porque se eliminó el camino de JSON plano.
El arreglo: pasa embedding_length=1536. El curso nunca lo hace, y la consecuencia es todo el problema del Paso 9. El docstring de la propia librería lo dice sin rodeos: definir la longitud impide insertar vectores de tamaños distintos, «pero sin ella, los embeddings no se pueden indexar». Fíjalo en la primera construcción, antes de que exista la tabla, y la columna se crea como vector(1536); olvídalo y tendrás una columna vector sin dimensión sobre la que no se puede construir ningún índice ANN.
El smoke test en sí tiene la forma correcta, y vale la pena nombrarlo como patrón: escribir → releer → comprobar → borrar. Los fotogramas muestran la secuencia de llamadas pero no el cuerpo completo de la función; esto es esa secuencia escrita.
# The verification routine narrated at [03:44:07]-[03:46:09], written to the pattern he describes.
from langchain_core.documents import Document
def verify_collection(vectorstore):
ids = vectorstore.add_documents(
[Document(page_content="test document", metadata={"source": "smoke-test"})]
)
hits = vectorstore.similarity_search("test document", k=1)
assert hits, "connected, but the write is not readable back"
vectorstore.delete(ids=ids) # cleanup, so the smoke test is idempotent
return hits
Salida esperada en una ejecución correcta: 🔗 Connecting to Supabase… / Host: db.<ref>.supabase.co / ✅ Connected!. El instructor lo ejecuta dos veces — una limpia y otra con el borrado comentado para que quede una fila que mirar en el panel 03:46:09. Es un recurso didáctico, no un patrón: mantén la limpieza. Un smoke test que deja residuos es un smoke test que dejarás de ejecutar contra producción.
Paso 6 — Mira el esquema que LangChain ha construido por ti
Refresca Database → Tables. Ahora hay dos tablas que no has escrito tú 03:46:09, 03:51:40, 03:53:35:
| Tabla | Columnas | Función |
|---|---|---|
langchain_pg_collection | 3: uuid, name, cmetadata | una fila por colección lógica; name es el collection_name que pasaste en Python |
langchain_pg_embedding | 5: id, collection_id, embedding, document, cmetadata | una fila por chunk: el vector, el texto original, los metadatos y una FK a su colección |
embedding contiene los valores vector de pgvector — en pantalla aparecen truncados, como [0.010925293, -0.0…], [-0.057647705, 0.0…], [-0.075805664, 0.0…]. El uuid de la colección es un UUID real de Postgres (693b2e31-0d86-4b03-9998-43b67d2c3f1… en pantalla); el id de la fila de embedding es una clave primaria de tipo cadena que resulta contener un UUID (c2d2b085-5c61-40db-b762-4df9e6a35ebb) — y por eso puedes proporcionar tus propios ids estables al llamar a add_documents y hacer que la reingesta sea idempotente. La clave foránea collection_id → langchain_pg_collection.uuid se declara con ON DELETE CASCADE.
De ahí salen directamente dos consecuencias, y ambas son de las que solo se aprenden después de haberse quemado:
- Borrar una colección no reduce el índice de tu tabla. Las filas desaparecen (por el cascade), pero la hinchazón del índice se queda hasta un
REINDEXo unVACUUM FULL. En un plan gratuito de 500 MB, eso importa. - Multi-tenancy por colección no es aislamiento. Si separar tenants es un requisito, usa proyectos/bases de datos separados o una política RLS real sobre
cmetadata, nocollection_names separados.
Paso 7 — La forma de producción: un objeto de configuración y una clase de servicio
El segundo fichero que recorre el curso, 03_production_example.py, es el que vale la pena interiorizar — no porque el RAG que contiene sea bueno (explícitamente no lo es), sino porque la forma es la correcta.
«Esto no es necesariamente un sistema RAG optimizado, sino una forma de enseñarte a usar pgvector desde Supabase.» 03:48:13
La forma es: un @dataclass Config con todos los parámetros ajustables, y una clase de servicio con el store inicializado de forma perezosa más los cuatro verbos que tu aplicación necesita de verdad.
El Config + RAGService reconstruidos (a partir de fotogramas en 03:47:40–03:50:05)
# RECONSTRUCTED from screen frames — pg_vector_section/6-supabase/03_production_example.py
# Ellipses mark code that was never visible on screen. See the notes below: as printed,
# this class does not run.
@dataclass
class Config:
# Database - use pooler URL in production
database_url: str = os.getenv(
"SUPABASE_DATABASE_URL",
os.getenv("DATABASE_URL", "postgresql://postgres:postgres@localhost:5432/postgres"),
)
collection_name: str = "production_documents"
# Model settings
embedding_model: str = "text-embedding-3-small"
chat_model: str = "gpt-4o-mini"
temperature: float = 0.0
# Search settings
default_k: int = 5
min_similarity: float = 0.5
class RAGService:
"""Production-ready RAG service with pgvector"""
def __init__(self, config: Optional[Config] = None):
self.config = config or Config()
self._vectorstore = None
@property
def vectorstore(self) -> PGVector:
"""Lazy initialization of vectorstore"""
if self._vectorstore is None:
embeddings = OpenAIEmbeddings(model=self.config.embedding_model)
self._vectorstore = PGVector(
embeddings=embeddings,
collection_name=self.config.collection_name,
connection=self.config.database_url,
use_jsonb=True,
)
return self._vectorstore
def _create_chain(self):
... # retriever, prompt, llm are built here, off-screen
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
return (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt # ChatPromptTemplate
| llm
| StrOutputParser()
)
def add_documents(self, documents: list[Document]) -> list[str]:
"""Add documents to the vectorstore"""
return self.vectorstore.add_documents(documents)
def search(self, query, k=None, filter_dict=None):
search_kwargs = {"k": k or self.config.default_k}
if filter_dict:
search_kwargs["filter"] = filter_dict
return self.vectorstore.similarity_search_with_score(query, **search_kwargs)
def ask(self, question: str) -> str:
"""Ask a question using RAG"""
return self.chain.invoke(question) # `self.chain` is never assigned on screen
def ask_with_sources(self, question: str) -> dict:
"""Ask a question and return sources"""
answer = self.ask(question)
return {
"answer": answer,
"sources": [
{"content": doc.page_content, "metadata": doc.metadata, "similarity": score}
for doc, score in docs_with_scores # undefined here — see note
],
}
Dos de esos métodos no pueden ejecutarse tal como están reconstruidos, y deberías arreglarlos en tu copia en lugar de suponer que los fotogramas estaban completos. ask() llama a self.chain, que nada en pantalla asigna — dale a la clase una segunda propiedad perezosa que memorice _create_chain(), igual que vectorstore. ask_with_sources() itera sobre docs_with_scores, un nombre que no está en el ámbito — debe llamar antes a self.search(question) y construir la respuesta a partir de esos mismos documentos; si no, las citas que devuelve no tienen relación con la respuesta que devuelve. Ese segundo bug es el más peligroso: un payload de citas que no se corresponde con el contexto recuperado es peor que no tener citas, porque parece procedencia y no lo es.
Los valores de configuración, verificados en pantalla en 03:47:40 y 03:48:05:
| Campo | Valor |
|---|---|
collection_name | "production_documents" |
embedding_model | "text-embedding-3-small" |
chat_model | "gpt-4o-mini" |
temperature | 0.0 |
default_k | 5 |
min_similarity | 0.5 |
use_jsonb | True |
Cuatro cosas que sacar de este fichero:
La inicialización perezosa es el detalle que sostiene todo. vectorstore es una @property protegida por if self._vectorstore is None: 03:48:25. Por tanto, construir RAGService() no abre ningún socket ni crea ningún cliente de OpenAI — y eso es lo que te permite importar el módulo en un test unitario, instanciarlo a nivel de módulo en FastAPI o pasárselo a un worker que quizá procese un job que nunca recupera nada. El momento del import no es el mismo que el del primer uso, y solo el segundo debería costarte una conexión a la base de datos.
La chain es la *misma* chain LCEL de la Parte 1. {"context": retriever | format_docs, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser() es exactamente la forma de rag_pipeline.py (líneas 110–113). Nada del hosting la ha tocado. Eso es la promesa de portabilidad haciéndose efectiva.
search() expone el filtrado por metadatos a propósito — «algo de filtrado por metadatos para que nuestros documentos recuperados sean más relevantes» 03:49:15 — y devuelve tuplas (Document, score) en lugar de documentos a secas, para que quien llama pueda ver lo buena que ha sido la coincidencia. Ambas decisiones son las que hacen posible ask_with_sources.
min_similarity: float = 0.5 se declara y, en pantalla, nunca se usa. Ningún camino de código lo lee. Dilo claramente en lugar de fingir que es un umbral que funciona — y si lo implementas tú, recuerda el aviso de la Parte 4: similarity_search_with_score en PGVector devuelve una *distancia*, no una similitud. Con la estrategia de coseno por defecto, cuanto más bajo, mejor. Un umbral que calibraste contra Chroma no es trasladable, y un ingenuo if score > 0.5: keep conservará justo tus peores coincidencias. Vuelve a derivarlo imprimiendo scores sobre un corpus que conozcas.
Paso 8 — Ejecútalo y verifica en el panel
Borra primero cualquier fila que haya quedado del smoke test, para que el recuento que vas a leer signifique algo. Después:
RAGService initializes → "Service is ready"
main() builds 3 sample Documents → metadata={"source": …, "topic": …}
service.add_documents(sample_docs)→ "✅ Added 3 documents"
service.search("How do I make pgvector faster?", k=2) → prints (doc, score) pairs
service.ask("What is pgvector and how to use it?") → prints the grounded answerRefresca el panel: langchain_pg_collection tiene una fila llamada production_documents; langchain_pg_embedding tiene 3 registros, cada uno con el texto del documento, un vector y los metadatos topic / source conservados en cmetadata 03:50:17, 03:53:35. El orden de las filas es arbitrario — «el orden en realidad no importa».
Paso 9 — Dale a la tabla un índice ANN
Este paso no está en el curso, y es la diferencia entre una demo y un sistema. Empieza confirmando en tu propia base de datos los dos hechos del callout del Paso 6:
-- 1. Does the embedding column have a declared dimension?
SELECT format_type(atttypid, atttypmod) AS embedding_type
FROM pg_attribute
WHERE attrelid = 'langchain_pg_embedding'::regclass
AND attname = 'embedding';
-- 'vector' -> dimensionless: NO ANN index can be built on it
-- 'vector(1536)' -> good
-- 2. What indexes actually exist?
SELECT indexname, indexdef FROM pg_indexes WHERE tablename = 'langchain_pg_embedding';
-- expect langchain_pg_embedding_pkey and ix_cmetadata_gin — and nothing on `embedding`
Si el tipo sale como vector a secas, te saltaste embedding_length= y la columna no tiene dimensión. Construir un índice sobre ella falla con el error del propio pgvector, literalmente: column does not have dimensions. Arregla en el sitio una tabla existente y luego construye el índice:
-- Only needed if the column was created without a dimension.
ALTER TABLE langchain_pg_embedding
ALTER COLUMN embedding TYPE vector(1536);
-- HNSW index. The operator class MUST match the distance your queries use:
-- vector_cosine_ops → <=> (cosine distance — PGVector's DEFAULT strategy)
-- vector_l2_ops → <-> (Euclidean)
-- vector_ip_ops → <#> (inner product)
CREATE INDEX ON langchain_pg_embedding
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
ANALYZE langchain_pg_embedding;
-- Query-time effort. Session-scoped; pgvector's default is 40.
SET hnsw.ef_search = 100;
Usa vector_cosine_ops salvo que hayas cambiado distance_strategy=: el valor por defecto de PGVector es DistanceStrategy.COSINE, así que sus queries emiten <=>. Un índice construido con la clase de operadores equivocada simplemente nunca se usa, y nada te lo dice — tu latencia se queda exactamente donde estaba.
Esas cifras no son arbitrarias. Son la tabla de presets de la Parte 8 03:16:04–03:17:04 y los valores de código de pgvector que el curso imprime para ellos 03:17:04–03:18:05:
| Régimen | m | ef_search | Prioridad |
|---|---|---|---|
| Prototipo | 16 | 40 | Velocidad |
| Producción | 16 | 100 | Equilibrio |
| Alta precisión | 32 | 200 | Precisión |
Lee esa tabla frente a los valores por defecto del propio pgvector — m = 16, ef_construction = 64, hnsw.ef_search = 40 — y se reduce a algo que de verdad puedes recordar: el preset «prototipo» no es más que pgvector tal como viene, y pasar a producción significa subir una variable de sesión de 40 a 100. El reparto de tareas es lo que lo hace manejable: m y ef_construction son de tiempo de construcción y cambiarlos requiere reconstruir; ef_search es de tiempo de query y puedes experimentar con él gratis. Si te falta recall, sube primero ef_search. Paga una reconstrucción del índice y la RAM extra de un m más alto solo cuando ef_search por sí solo no te lleve hasta allí.
pgvector incluye además un tipo de índice IVFFlat, que el curso nunca menciona. Se construye mucho más rápido y usa mucha menos memoria que HNSW, pero tiene tres aristas peligrosas: hay que construirlo después de que la tabla ya contenga datos (agrupa los vectores que puede ver), su parámetro lists tiene que dimensionarse según el número de filas (rows / 1000 hasta 1M de filas, sqrt(rows) a partir de ahí) y su ivfflat.probes de tiempo de query vale 1 por defecto, lo que da un recall pésimo hasta que lo subes (empieza en torno a sqrt(lists)). Además, el recall se degrada a medida que insertas más allá del punto en que se entrenó. HNSW es más lento y más voraz al construirse, y es el valor por defecto correcto para un corpus que no para de crecer — es decir, cualquier corpus RAG. Recurre a IVFFlat solo cuando el tiempo de construcción del índice o la RAM sean la restricción que manda.
Si prefieres ser el dueño del esquema por completo — y deberías, en cuanto el sistema importe —, la versión escrita a mano es pequeña. Las lecciones anteriores de pgvector en local del curso construyen algo parecido en el SQL Editor (se menciona en 03:50:17, fuera de este capítulo):
-- A hand-owned schema. You control the names, the dimension, the index and the constraints.
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE documents (
id bigserial PRIMARY KEY,
content text NOT NULL,
metadata jsonb NOT NULL DEFAULT '{}'::jsonb,
embedding vector(1536) NOT NULL, -- must match your embedding model, forever
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
-- Metadata filtering: a GIN index makes jsonb predicates cheap.
-- (LangChain's own table already has this one, as ix_cmetadata_gin.)
CREATE INDEX ON documents USING gin (metadata jsonb_path_ops);
ALTER TABLE documents ENABLE ROW LEVEL SECURITY;
El vector(1536) de ese DDL es el invariante 2 escrito en tu esquema como una restricción. Cambia el embedding model y la propia base de datos rechazará la inserción — que es exactamente el fallo ruidoso que quieres, en lugar del fallo silencioso de misma-dimensión-distinto-modelo de la Parte 4.
El panel de Supabase muestra también un botón Index Advisor en la vista de tabla 03:53:35. El curso nunca lo pulsa. Vale la pena echarle un vistazo en una tabla con tráfico real, pero razona sobre índices convencionales de Postgres y no sustituye a elegir tus propios parámetros ANN.
Paso 10 — Activa Row Level Security — en las dos tablas
Abre el Table editor. Las dos tablas recién creadas por LangChain llevan una insignia roja UNRESTRICTED y un botón «RLS disabled». Pasa el ratón por encima:
«Cualquiera puede acceder a esta tabla a través de la Data API porque RLS está desactivado.» 03:53:25
Es la casilla del Paso 1 pasando factura. La Data API está activada y RLS desactivado, así que cualquiera que tenga tu publishable key puede leer todos los documentos y todos los vectores de tu store — tu corpus, el texto de tus clientes y todo lo que los embeddings codifican de él.
Solución, tabla por tabla: haz clic en la insignia → View policies → Enable RLS → confirma «Are you sure you want to enable Row Level Security on this table?» → Enable. Luego repítelo con la segunda tabla 03:54:27. Activar RLS en langchain_pg_collection no hace nada por langchain_pg_embedding. La insignia desaparece cuando has terminado con las dos.
El equivalente en SQL, que es lo que deberías poner de verdad en una migración para que no dependa de que alguien se acuerde:
-- Do this for BOTH LangChain tables, on every new deployment.
ALTER TABLE langchain_pg_collection ENABLE ROW LEVEL SECURITY;
ALTER TABLE langchain_pg_embedding ENABLE ROW LEVEL SECURITY;
«Siempre deberías activar RLS. Así tus datos están protegidos.» 03:53:25
Los compromisos operativos que acabas de comprar
El planteamiento del capítulo es «no tienes que preocuparte de nada» 03:34:19. Eso es lenguaje comercial, y el propio recorrido de la fuente lo contradice en menos de quince minutos. El hosting managed elimina las operaciones del host. No elimina las decisiones de base de datos. Esta es la lista honesta de lo que ahora es tuyo.
| Ya no es tuyo | Ahora es tuyo |
|---|---|
Parches del SO, pg_upgrade, aprovisionamiento de discos | El diseño del esquema, la dimensión de la columna vectorial y los parámetros del índice (m, ef_construction, ef_search) |
| El cron de copias de seguridad, la configuración de la replicación, el montaje del failover | El modo de connection pooling — directo frente a transaction frente a session |
| La planificación de capacidad del hardware | El límite de almacenamiento de 500 MB / 8 GB y lo que cuenta para él |
| La seguridad física | RLS, por tabla, en cada despliegue |
| La ingeniería de disponibilidad | El egress (5 GB gratis) y el coste de devolver el texto de document en cada query |
| — | La latencia de red entre la app y la base de datos, que ahora es una cifra real en tu p95 |
| — | La superficie de vendor lock-in: cuánto adoptas de la plataforma de Supabase (auth, Data API, Edge Functions) |
El connection pooling es la mayor laguna real de la fuente. El dataclass Config lleva el comentario # Database - use pooler URL in production 03:47:40 — así que el curso sabe que importa — y el fichero que lo enseñaría, 02_connection_pooling.py, se salta explícitamente: «Me salto el connection pooling porque es algo que podéis investigar vosotros» 03:46:09. No se enseña en ningún otro sitio. Cubre esa laguna tú mismo, porque es el fallo que tumba un servicio RAG que funcionaba en cuanto hay carga:
- Las conexiones de Postgres son caras y limitadas. Una instancia managed pequeña puede admitir decenas, no miles. Cada worker de uvicorn, cada invocación de Lambda y cada tarea en segundo plano que construye un
PGVectorabre una — yPGVectorcrea un engine de SQLAlchemy nuevo, con su propio pool, por cada cadena DSN que le pasas. Construye el store una vez por proceso, o pasa unEnginecompartido comoconnection=en lugar de una cadena. - Un servicio de larga duración (VM, contenedor, FastAPI detrás de uvicorn) debería usar la conexión directa más ese pool del lado de la aplicación, dimensionado según tu número de workers — no una conexión por request.
- Un despliegue serverless tiene que usar el transaction pooler, porque no hay ningún proceso que mantenga una conexión entre invocaciones, y mil arranques en frío concurrentes agotarían si no los slots de conexión del servidor y empezarían a devolver errores a los usuarios. Ten en cuenta la restricción que trae: el pooling en modo transacción no te da estado a nivel de sesión, así que un
SET hnsw.ef_search = …a secas no sobrevivirá a la siguiente sentencia. UsaSET LOCAL hnsw.ef_search = 100dentro de la transacción que ejecuta la query, o fija el valor como predeterminado del rol o de la base de datos conALTER ROLE … SET. - El session pooler existe por una sola razón: estás en una red solo IPv4 y no puedes llegar al host directo. Es un fallback de compatibilidad, no una estrategia de escalado.
La latencia cambia de naturaleza. Una query a Chroma en local es una lectura de la page cache. Una query a Supabase es un viaje de ida y vuelta TCP a otra región, en CPU compartida, más la búsqueda ANN, más devolver el texto de los chunks por la red. Pon la aplicación en la misma región que la base de datos. La instrumentación de la Parte 7 es lo que lo hace visible: si el p95 de tu retrieval se disparó tras la migración, los primeros sospechosos son un índice ANN ausente, una región que no coincide y el establecimiento de conexión en cada request.
El egress es una partida real del presupuesto. 5 GB gratis. Cada retrieval devuelve el texto de document, no solo vectores, y si recuperas k=5 chunks de ~1,000 caracteres por query, son ~5 KB por request antes de la sobrecarga. Un millón de requests son ~5 GB. No es un muro con el que vayas a chocar en desarrollo, y es uno que deberías poder calcular antes de que te sorprenda.
Copias de seguridad. Postgres managed te da copias automáticas en los planes de pago, y los planes gratuitos normalmente no te dan recuperación a un momento dado (point-in-time recovery). Tus vectores son datos derivados — siempre puedes volver a hacer re-embed desde los documentos de origen —, así que lo que de verdad tienes que respaldar es el corpus de origen y el código de ingesta, no la base de datos.
Migrar un corpus de Chroma existente
La fuente nunca lo trata — vuelve a ejecutar una demo desde cero —, pero lo vas a necesitar, y es corto. Como los vectores son datos derivados, solo hay dos opciones honestas:
- Re-embed desde el origen (recomendado). Ejecuta tu pipeline actual de carga → split → embed → store con el constructor
PGVectoren lugar deChroma. Coste: un re-embed completo del corpus (context-embedding-3-small, $0.02 por 1M de tokens — lo bastante barato como para que casi siempre sea la respuesta correcta). Ventaja: aprovechas para arreglar el chunking a la vez, y sabes exactamente qué hay en el store nuevo. - Copiar los vectores. Saca
documents,embeddings,metadataseidsde Chroma e insértalos conadd_embeddings(), que recibe vectores ya calculados y se salta la llamada de embedding. Más barato en dólares, más frágil: tienes que garantizar que los vectores los produjo el mismo modelo con la misma dimensión, y dependes de una estructura de tablas que es de LangChain y que ya ha cambiado una vez.
En ambos casos, ejecuta el mismo conjunto de sondas de retrieval contra los dos stores antes y después y compara los IDs de documento del top-k. Una migración que cambia en silencio lo que se recupera es una migración que cambia en silencio todas las respuestas que da tu sistema — y, según el invariante 4, nada lanzará un error.
Lo que la fuente no cubre, dicho claramente
Ser claro sobre los límites del material es más útil que taparlos:
- La implementación del connection pooling — señalada como importante, saltada explícitamente 03:46:09, nunca enseñada.
- La creación del índice ANN en la instancia alojada — el curso dice que LangChain «ha creado algunos índices automáticamente» y nunca los inspecciona. No crea ningún índice vectorial; el Paso 9 existe para cubrir esa laguna.
- El argumento
embedding_length— nunca se menciona, y sin él la columna no se puede indexar en absoluto. - La migración de un corpus existente — no se trata en ninguna parte.
- Copias de seguridad, PITR, simulacros de restauración — no se tratan.
- Políticas RLS — solo se muestra cómo activar RLS. Escribir una política real queda fuera del alcance.
- Multi-tenancy — no se discute; la abstracción de colección invita aquí a una respuesta equivocada.
- Práctica con Neon y RDS — se nombran en una diapositiva, nunca se demuestran. Todo el recorrido es interfaz específica de Supabase; solo el DSN y el SQL son trasladables.
- El comportamiento de los arranques en frío con scale-to-zero — nunca se menciona.
Nada de eso es una crítica a la fuente — ella misma lo dice, y el alcance es deliberado:
«Obviamente, esto no es un curso de Supabase ni de pgvector… Es un curso sobre bases de datos vectoriales.» 03:52:22
Es una lista de las cosas que tienes que ir a aprender a otro sitio antes de que este stack soporte tráfico.
Checklist: llevar un sistema RAG de una carpeta a una base de datos alojada
Elegir
- Estima tu número de vectores y sitúalo en la escalera de escala: <100K → lo local sigue valiendo; 100K–10M → pgvector managed; 10M+ → plantéate el self-hosting.
- Por defecto, Supabase, salvo que (a) tu carga pase mucho tiempo ociosa y los arranques en frío sean aceptables → Neon, o (b) tu organización ya viva en un hiperescalador → RDS / Cloud SQL / AlloyDB.
- Vuelve a calcular el coste con tus cifras. 500 MB gratis ≈ decenas de miles de chunks de 1536-d.
- Confirma que pgvector está disponible en el plan que compras, y que la dimensión de tus embeddings es ≤ 2,000 si piensas indexar una columna
vector.
Aprovisionar
- Crea la organización y luego el proyecto.
- Copia la contraseña de la base de datos al crearla. Se muestra una sola vez. (Recuperación: Database → Settings → Reset database password → Generate → Reset.)
- Elige la región más cercana a tus servidores de aplicación; en la práctica es permanente.
- Marca «Enable automatic RLS» al crear el proyecto, o deja por escrito que lo activarás a mano en las dos tablas de LangChain.
- Activa la extensión
vector(Database → Extensions, esquemaextensions), aunque Supabase la traiga preinstalada yPGVectorfuera a lanzar elCREATE EXTENSIONpor su cuenta.
Conectar
- Connect → pestaña Direct. Elige direct connection para servicios de larga duración, transaction pooler para serverless y session pooler solo si estás atascado en IPv4.
- Pon el DSN en
.envcomoSUPABASE_DATABASE_URL. Quita los corchetes[…]del marcador de la contraseña. Confirma el puerto 5432. Confirma el project ref. - Reescribe el esquema a
postgresql+psycopg://antes de pasárselo aPGVector, o SQLAlchemy intentará usar psycopg2 y fallará. - Nunca hagas commit de
.env. - Mantén el fallback
SUPABASE_DATABASE_URL or DATABASE_URLpara que el mismo código funcione contra un Postgres local.
Conectar el código
- Sustituye
Chroma(...)porPGVector(embeddings=…, collection_name=…, connection=…, embedding_length=1536, use_jsonb=True). Ojo:embeddings=, noembedding=. - Define
collection_nameuna sola vez, enConfig. Dos ficheros con dos nombres crean dos colecciones. - Mantén el embedding model idéntico al que construyó tu índice local (
text-embedding-3-small, 1536 dims). - Inicializa el vector store de forma perezosa detrás de una
@property, y constrúyelo una vez por proceso. - Haz que
ask_with_sourcescite los documentos a partir de los que realmente respondió — un solo retrieval, reutilizado. - Smoke test: añadir → buscar → comprobar → borrar. Mantén la limpieza.
Blindar
- Inspecciona el esquema:
langchain_pg_collection(3 columnas) ylangchain_pg_embedding(5 columnas). - Comprueba
format_type(atttypid, atttypmod)sobreembedding:vectora secas significa sin dimensión →ALTER … TYPE vector(1536)antes de poder indexar nada. - Lista los
pg_indexesde la tabla. Espera una PK eix_cmetadata_gin, y nada sobreembeddinghasta que lo construyas. - Crea tú mismo el índice ANN con la clase de operadores correspondiente:
USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64), y luegoANALYZE. - Fija
hnsw.ef_search = 100para producción (el valor por defecto es 40); súbelo más si filtras por metadatos, y solo entonces tocam. ENABLE ROW LEVEL SECURITYen las dos tablas, en una migración, no a base de clics.- Dimensiona el pool de conexiones según tu número de workers; no abras una conexión por request. Con un transaction pooler, usa
SET LOCALpara los GUCs de sesión.
Verificar
- Ejecuta las mismas sondas de retrieval contra el store antiguo y el nuevo y compara los IDs de documento del top-k.
- Vuelve a medir el p95 del retrieval (la instrumentación de la Parte 7). Si ha empeorado, investiga el índice, luego la región y luego el pooling, en ese orden.
- Vuelve a derivar cualquier umbral de similitud a partir de los scores de pgvector — son distancias de coseno, así que cuanto más bajo, mejor, y nada se traslada desde Chroma.
- Confirma el margen de almacenamiento, egress y conexiones que te queda, y apunta la cifra que disparará el cambio de plan.
Después, ve a la Parte 9 y pon la cache de embeddings y la cache de respuestas delante de todo esto, porque la query más barata contra una base de datos alojada es la que nunca envías.