Allotjament en producció: Supabase i pgvector
D'una carpeta local a Supabase i pgvector: serveis gestionats o infraestructura pròpia, implementació i operació.
Tot el que has construït fins ara viu en una carpeta. persist_directory="./chroma_db/" és un plantejament de desenvolupament: un procés, un disc, sense concurrència, sense còpies de seguretat, sense control d'accés i un corpus que s'evapora en el moment que fas docker build sense un volum. El curs marca la transició amb una frase:
«Ja ho has construït en local. Ara despleguem-ho.» 03:33:18
Aquesta part tracta d'aquest pas. Respon tres preguntes, en aquest ordre: a qui contracto Postgres, com hi trasllado exactament el pipeline que ja tinc i quines responsabilitats operatives acabo d'assumir que no tenia quan el magatzem era una carpeta. El fil pràctic és la demostració de Supabase del curs a 03:36:00–03:54:27.
En termes del model mental de la part 1, aquesta part afecta exactament una casella — el Store + Index de la fase A — i no en toca cap altra. Els carregadors, el divisor, el model d'embeddings, el recuperador, el prompt i la cadena no canvien. El que canvia és l'adreça física dels vectors i, de manera menys evident, el tercer pressupost: els diners deixen de ser una factura d'API i es converteixen en una partida mensual, més el trànsit de sortida, més el teu temps.
L'afirmació d'una sola línia, i per què només és mig certa
L'afirmació pedagògica central del capítol de Supabase és que passar a producció canvia exactament una línia de Python:
«Exactament el mateix que teníem en local… ara ho tenim en un lloc del núvol on ens podem connectar.» 03:52:22
Pel que fa al codi de recuperació, això és cert, i ho és gràcies a una decisió de disseny que has heretat de franc: la interfície VectorStore de LangChain és un punt de separació real. El constructor de Chroma i el de PGVector accepten arguments amb nom diferents, però exposen la mateixa interfície add_documents / similarity_search / similarity_search_with_score / as_retriever; per tant, a tots els consumidors posteriors al magatzem els és indiferent quin hi ha al darrere.
Aquest és l'«abans» — codi local real, distribuït amb el curs:
# /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,
)
I el «després» té la mateixa estructura, amb un DSN on abans hi havia el directori. El paquet d'integració és langchain-postgres (uv add langchain-postgres), que incorpora SQLAlchemy 2, els enllaços de Python per a pgvector i psycopg 3 — no psycopg2, una distinció que serà important d'aquí a un moment. Fixa't bé en la ruta d'importació: és langchain_postgres, no langchain_community, exactament com apareix en pantalla a 03:42:35. És el mateix parany d'instal·lació que langchain-chroma enfront de langchain-community a la part 2, i provoca els mateixos errors confusos amb aparença d'avís d'obsolescència si t'equivoques.
# 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 d'aquests cinc arguments amaguen paranys, i el curs només en comenta un.
| Concepte | Chroma | PGVector |
|---|---|---|
| Argument amb nom dels embeddings | embedding= (i embedding_function= en tornar a obrir) | embeddings= |
| On viuen les dades | persist_directory= | connection= (una cadena DSN o un Engine de SQLAlchemy) |
| Partició lògica | collection_name → una col·lecció real de Chroma | collection_name → una fila a langchain_pg_collection |
| Emmagatzematge de metadades | implícit | use_jsonb=True |
| Dimensionalitat dels vectors | inferida, invisible | embedding_length= — omès per defecte; en aquest cas no es pot indexar res |
Per tant, l'afirmació sobre el codi se sosté. El que no se sosté és la implicació que, per això, la migració surt de franc. Entre el constructor i un sistema que posaries davant d'un usuari, has adquirit: seguretat a escala de fila que has d'activar manualment, una decisió sobre l'agrupació de connexions que el curs omet explícitament, un índex ANN que ningú no t'ha creat, un límit d'emmagatzematge mesurat en megabytes, un límit de trànsit de sortida i una anada i tornada per la xarxa on abans hi havia una lectura de la memòria cau de pàgines. La resta d'aquesta part tracta de tot això.
Servei gestionat o allotjament propi: el compromís que realment assumeixes
La part 8 ajustava l'índex i la part 9 en calculava el preu. Aquesta és la versió breu que necessites aquí per emmarcar la comparació de proveïdors: les franges d'escala de la font situen menys de 100K vectors a Chroma local, 100K–1M a Pinecone serverless, 1M–10M a pgvector gestionat i 10M+ a pgvector amb allotjament propi 03:31:53. Les tres opcions d'allotjament d'aquesta part són els proveïdors concrets d'aquesta franja de pgvector gestionat — on comencen gairebé tots els sistemes reals i on es queda la majoria.
La invariant 5 — a cada capa has de «triar-ne 2» — apareix aquí com a diners / càrrega operativa / control:
| Gestionat (Supabase, Neon, RDS) | Postgres + pgvector amb allotjament propi | |
|---|---|---|
| Càrrega operativa | Gairebé zero — sense aplicar pedaços, sense pg_upgrade, sense cron de còpies de seguretat, sense configurar la replicació | «Molt significativa» 03:21:10 |
| Cost amb 500K vectors | ~$35/mes | ~$20/mes, més les teves hores |
| Cost amb 5M / 50M vectors | ~$100 / ~$400 al mes | ~$75 / ~$300 al mes |
| Control | Limitat — tens els controls que exposa el proveïdor | Total |
| Responsabilitat en cas de fallada | L'alerta arriba al proveïdor | L'alerta t'arriba a tu |
Aquestes xifres provenen del gràfic de divergència de la part 9 03:24:59–03:26:20. Fixa't en la forma, no en els dígits: el sobrecost del servei gestionat és d'aproximadament $15/mes amb 500K i $100/mes amb 50M — un error d'arrodoniment al costat d'una sola jornada mensual d'enginyeria dedicada a administrar Postgres. La diferència que sí que es dispara en aquell gràfic és la de Pinecone respecte de pgvector ($1,500+ enfront de $300 amb 50M), no la de pgvector gestionat respecte de l'allotjament propi.
La posició del formador, que es manté des del capítol de costos, és inequívoca: comença amb un servei gestionat. El temps que estalvies val més que la diferència de preu, i pots canviar més endavant precisament perquè pgvector és la mateixa extensió en tots dos entorns.
«Ens centrem sobretot en pgvector perquè és de codi obert, és fàcil d'incorporar com a extensió a una base de dades Postgres i funciona.» 03:52:22
Aquesta frase conté tot l'argument estratègic. pgvector no és una nova superfície operativa. És un tipus de columna en una base de dades de la qual la teva organització ja sap fer còpies de seguretat, replicar-la, monitorar-la, concedir-hi permisos i restaurar-la. Una base de dades vectorial dedicada és un segon sistema amb estat, amb un segon plantejament de còpies de seguretat, un segon model d'autenticació i un segon procediment de guàrdia. Totes tres opcions d'allotjament següents són Postgres gestionat — cap base de dades vectorial dedicada no supera la selecció final, i aquesta omissió és precisament el missatge.
Els tres camins cap a producció
La font redueix el mercat a tres opcions i reconeix que és una selecció de mercat, no el resultat d'una prova comparativa:
«És clar que n'hi ha més, però em limito a tres de les més sol·licitades.» 03:33:18
El criteri de selecció declarat és la demanda, no la superioritat tècnica. Railway, Fly.io, Render, Crunchy Bridge, Timescale/Tiger, DigitalOcean Managed Postgres, Cloud SQL, AlloyDB i un simple Postgres amb Docker i allotjament propi existeixen, tots executen pgvector, i cap no va ser avaluat i descartat — senzillament no eren a la diapositiva.
| Supabase | Neon | AWS RDS | |
|---|---|---|---|
| Etiqueta a la diapositiva | ★ Recomanat | 🏷 Serverless | 🏷 Empresarial |
| Preu destacat a la diapositiva | $25/mes | $19/mes | $60/mes |
| Pla gratuït | $0, base de dades de 500 MB | $0, 512 MB d'emmagatzematge | sense pla gratuït permanent |
| Primer nivell de pagament | Pro $25/mes, base de dades de ~8 GB | Pro ~$19/mes | petit ~$30/mes, nivell mitjà ~$60/mes |
| Nivell superior | Team ~$599/mes | — | escala dins del catàleg de l'hiperescalador |
| pgvector | inclòs en tots els nivells | inclòs | admès al motor Postgres |
| Factor diferencial | millor relació qualitat-preu; un pla gratuït realment gratuït; autenticació + REST + emmagatzematge en un sol producte | escalat a zero — deixes de pagar pel còmput inactiu | oferta completa: Multi-AZ, PITR, IAM, VPC, rèpliques de lectura |
| Quan triar-lo | opció per defecte; qualsevol càrrega estable | càrregues variables, amb pics o amb molta inactivitat | equips que ja treballen a AWS |
Una fila d'aquesta taula és soroll i l'hauries d'ignorar: els plans gratuïts estan empatats. Els 500 MB de Supabase i els 512 MB de Neon difereixen en 12 MB — un 2.4%, i 512 MB és simplement 0.5 GiB expressat amb exactitud davant d'una xifra rodona de màrqueting. Això no decideix res.
Els preus són els que apareixen a la diapositiva i es diuen a 03:33:18–03:35:20. El mateix formador els matisa — «uns 8 GB», «en el moment d'enregistrar aquest vídeo» —, i el vídeo es va publicar el 2026-05-26. Pren-los com una orientació del mercat, no com a pressupostos. Les pàgines de preus dels proveïdors són l'única font de referència per a l'import que acabaràs pagant.
Tres correccions a la font, exposades clarament i sense dissimular-les:
- El nivell Team de Supabase costa $599/mes, no $5.99. Els subtítols generats automàticament ho transcriuen com a «$5.99» tant al capítol 17 03:34:19 com al capítol 18 03:37:00 — la mateixa xifra dita dues vegades, amb un error de posició del punt decimal. Un nivell per a equips amb un preu inferior al pla Pro de $25 és impossible. Escriu $599.
- El formador dona preus d'AWS RDS que no són coherents entre si. A 03:34:19, el «punt de partida són $60 al mes»; a 03:35:20, «la instància de nivell mitjà… costa uns $60 al mes i la petita, uns $30 al mes». La lectura coherent és ~$30 la petita / ~$60 la mitjana, amb el nivell mitjà destacat a la diapositiva. Observa també que la xifra independent del capítol de costos — pgvector a RDS ≈ $32/mes amb 500K vectors 03:23:35 — concorda amb la lectura «petita ≈ $30», cosa que la corrobora.
- «Equips que ja treballen a AWS o Google Cloud Platform» 03:35:20 és imprecís: RDS només és d'AWS. La generalització correcta és queda't dins del núvol que ja fa servir l'organització; a GCP, els equivalents són Cloud SQL for PostgreSQL i AlloyDB, tots dos compatibles amb pgvector.
El procediment de decisió, prou breu per memoritzar-lo:
- Tria Supabase per defecte. Pla gratuït per aprendre i prototipar; Pro de $25 quan superis els 500 MB.
- Tria Neon si la càrrega és variable o té molta inactivitat i pots assumir una arrencada en fred.
- Tria RDS (o Cloud SQL / AlloyDB) si el teu equip ja treballa en aquell hiperescalador. El factor decisiu és el teu perímetre, no el preu.
- Repeteix els càlculs amb les teves pròpies xifres abans d'acceptar l'opció per defecte — la recomanació és un punt de partida, no una llei.
- Verifica que pgvector estigui disponible al nivell que tries. Tots tres l'inclouen. Un quart proveïdor podria no fer-ho.
- Aprèn amb el pla gratuït; passa a un de superior quan mesuris un límit — emmagatzematge, connexions o trànsit de sortida —, no per una sensació.
L'últim punt és una promesa que el curs compleix: tots els capítols pràctics que queden estan dissenyats per encaixar a Supabase Free, i el formador ho diu — «no us caldrà gastar ni un cèntim» 03:35:20.
Supabase, en concret
Supabase es descriu com «la plataforma de desenvolupament de Postgres» — construeix en un cap de setmana, escala a milions — i el paquet inclou: una base de dades Postgres, autenticació, API instantànies generades automàticament, Edge Functions, subscripcions en temps real, emmagatzematge de fitxers i embeddings vectorials 03:36:00. Aquest últim punt és pgvector. No adoptes una base de dades vectorial nova; trasllades la mateixa extensió del portàtil al Postgres gestionat d'algú altre.
Aquesta agrupació de serveis explica bona part de la recomanació. Una aplicació RAG real acostuma a necessitar també autenticació, una capa d'API i un lloc per desar els PDF originals. Si, altrament, els contractaries a tres proveïdors, la comparació dels $25 no és $25 contra $19.
El pla gratuït, complet (03:36:00–03:37:00, llegit de la pàgina de preus):
| Concepte del pla gratuït | Valor |
|---|---|
| Preu | $0/mes |
| Mida de la base de dades | 500 MB (línia secundària de la targeta: CPU compartida • 500 MB de RAM) |
| Peticions d'API | Il·limitades |
| Usuaris actius mensuals | 50,000 |
| Trànsit de sortida | 5 GB |
| Trànsit de sortida en memòria cau | 5 GB |
| Emmagatzematge de fitxers | 1 GB |
| Suport | Comunitat |
Nivells de pagament: Pro $25/mes (etiquetat com a «més popular», base de dades de ~8 GB), Team $599/mes.
El procediment pràctic, de principi a fi
El recurs didàctic que fa servir aquí el curs és la repetició deliberada amb un backend diferent — mateixos documents, mateix model d'embeddings, mateixa cerca de similitud, magatzem nou:
«…fer exactament el que hem fet abans. Perquè pugueu veure la visió completa.» 03:35:20
Val la pena copiar-ho quan facis una migració real. Torna a executar una càrrega de treball de la qual ja coneguis les respostes, de manera que qualsevol canvi es pugui atribuir al magatzem i a res més.
El que segueix és la seqüència de 03:36:00–03:54:27, reorganitzada perquè les dues decisions de seguretat quedin juntes en lloc de separades per quinze minuts.
Pas 1 — Crea l'organització i el projecte
- supabase.com → Pricing → llegeix la targeta Free → Start for free → inicia la sessió.
- Crea primer una organització — les organitzacions agrupen projectes. Posa-li un nom (el curs fa servir
VectorCourse), tipus Personal, pla $0/mes. - New project. Un projecte és «la seva pròpia instància dedicada»: posa-li un nom i resol els tres punts següents. Quan s'acaba l'aprovisionament, arribes a la branca
main, amb l'etiquetaPRODUCTION.
La contrasenya de la base de dades. El formulari té un botó Generate a password. Copia-la abans de clicar res més. Només es mostra una vegada i no es pot recuperar — només restablir. Ocuparà el camp [PASSWORD] de totes les cadenes de connexió que enganxis.
«Copiaré aquesta contrasenya perquè més endavant realment la necessitareu.» 03:38:02
L'has perduda? Database → Settings → Reset database password → Generate → Reset. Generar un valor nou no és suficient; has de clicar Reset perquè tingui efecte 03:43:06, i després actualitzar .env.
La regió. El formulari diu que seleccionis la regió més propera als usuaris. El curs tria East US (North Virginia) us-east-1, que porta l'etiqueta RECOMMENDED; la llista d'Amèrica que es veu en pantalla també mostra us-west-1 (N. Califòrnia), us-west-2 (Oregon), us-east-2 (Ohio), ca-central-1 i eu-west-1 a Europa.
Afina aquest consell un pas més: tria segons on s'executa el servidor de l'aplicació, no on sou tu o els usuaris. Un usuari fa una anada i tornada a l'aplicació; l'aplicació en fa diverses a la base de dades per petició (obtenir la fila de la col·lecció, executar la cerca ANN, recuperar el text del fragment), i cadascuna es multiplica amb cada reintent i cada consulta addicional. Situa l'aplicació i la base de dades juntes, i després preocupa't de l'usuari. La regió també és pràcticament permanent — Supabase no permet canviar-la al mateix projecte, de manera que canviar-la implica un projecte nou i una reingesta completa.
(Imprecisió de la font, assenyalada: a 03:38:02, els subtítols fan que el formador proposi «West North Carolina» com a regió alternativa. Aquesta regió de Supabase no existeix. Considera-ho un lapsus o un artefacte dels subtítols; només us-east-1 es confirma en pantalla.)
Els dos interruptors de seguretat — llegeix això abans de clicar Create. El formulari de projecte nou té:
- Enable Data API — marcat per defecte. «Genera automàticament una API RESTful per al teu esquema public», que és el que permet que
supabase-jsfuncioni des d'un navegador. - Enable automatic RLS — desmarcat per defecte. Crea un disparador d'esdeveniments que activa la seguretat a escala de fila per a cada taula nova de l'esquema
public.
Pas 2 — Recull les credencials
Clica Connect a la barra superior. El diàleg ofereix quatre pestanyes, i no són intercanviables 03:39:02:
| Pestanya | Què et proporciona | Quan fer-la servir |
|---|---|---|
| Framework | fragments de codi de biblioteques client (supabase-js, etc.) | crides Supabase des del codi de l'aplicació mitjançant la Data API |
| Direct | una cadena de connexió directa a Postgres | aquesta és la que necessites — LangChain parla Postgres |
| ORM | configuració de tipus Prisma/Drizzle | l'aplicació ja té un ORM |
| MCP | connectar un agent al projecte | eines per a agents |
Dins de Direct hi ha tres mètodes de connexió, i equivocar-se en triar provoca un incident de producció, no un error de sintaxi. El mateix text de Supabase els relaciona amb la durada dels processos:
| Mètode | Descripció del proveïdor | Tria'l per a |
|---|---|---|
| Direct connection | connexions persistents de llarga durada | un servei FastAPI/uvicorn de llarga execució, un procés de treball, una VM, «contenidors de llarga durada» |
| Transaction pooler | clients sense estat, amb cada interacció «breu i aïllada» | Lambda, funcions Vercel/Cloudflare, qualsevol entorn que arrenqui en fred a cada petició |
| Session pooler | una alternativa a la connexió directa «quan et connectes mitjançant una xarxa IPv4» | la teva xarxa o plataforma no pot arribar al servidor directe, que només té IPv6 |
El selector Type presenta la mateixa informació en format URI o PSQL. Val la pena entendre les cinc dades en lloc de memoritzar el bloc sencer 03:40:02:
| Element | Valor |
|---|---|
| base de dades | postgres |
| usuari | postgres |
| port | 5432 — «el port és molt important» |
| servidor | db.<project-ref>.supabase.co |
| contrasenya | la que has desat en crear el projecte |
El project ref és el subdomini aleatori que identifica la instància — el del curs és yynnyoubueyfbvgnpzpq; el teu serà diferent. Apareix al nom del servidor i a tots els URL del tauler. Ja que hi ets, copia també el Project URL i la publishable key — no calen per al camí de pgvector, però les necessitaràs tan bon punt facis servir la Data API.
Pas 3 — Activa l'extensió vector
Database → Extensions → cerca vector → activa l'interruptor → diàleg «Enable vector» → conserva l'esquema extensions (DEFAULT) → Enable extension 03:41:02.
Dues coses fan que aquest pas sigui gairebé redundant, i una fa que valgui la pena fer-lo igualment. Supabase preinstal·la pgvector — el mateix fitxer font del formador porta el comentari # Note: Supabase has pgvector pre-installed — i PGVector inclou create_extension=True per defecte, de manera que la mateixa biblioteca executa CREATE EXTENSION IF NOT EXISTS vector (protegit per un bloqueig consultiu de Postgres) durant la construcció. Clica-ho igualment: fa visible la dependència al tauler, i marca la diferència entre «funciona al meu projecte» i un pas de configuració documentat que algú altre pot reproduir. També és important el dia que l'aplicació es connecta amb un rol restringit o de només lectura que no té permís per crear extensions — aleshores l'actives aquí una sola vegada, manualment, i passes create_extension=False al codi.
L'equivalent SQL, si prefereixes l'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';
Abans d'executar cap codi, mira Database → Schema Visualizer: diu «No tables in schema.» Recorda-ho. És el que permet entendre que les dues taules que apareixen al pas 6 les ha creat LangChain, i que no hi eren des del principi.
Hi ha dues portes d'entrada a l'esquema, i el curs tria deliberadament la segona: l'SQL Editor (enganxar manualment CREATE EXTENSION / CREATE TABLE) i el codi de l'aplicació (PGVector(...) crea allò que necessita). «De fet, podem anar a l'editor SQL i començar a executar aquestes ordres… Però ho fem tot amb codi.» 03:50:17
Pas 4 — Incorpora 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-...
Pas 5 — Connecta des del codi i fes una prova bàsica de funcionament
El fitxer del curs és 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
Hi ha dos detalls que val la pena adoptar directament, i un que cal corregir.
SUPABASE_URL or DATABASE_URL és un patró realment reutilitzable 03:44:07. El mateix script s'executa contra un Postgres al portàtil sense compte al núvol i contra producció sense cap canvi. Et proporciona un destí local de proves d'integració amb el mateix motor que producció — cosa que una combinació de Chroma en local i pgvector en producció no pot oferir mai.
use_jsonb=True no és decoratiu 03:44:07, 03:48:13. Desa les metadades dels documents com a JSONB de Postgres — una forma binària ja analitzada que admet operadors de contenció i índexs GIN — en lloc de json simple, que s'emmagatzema com a text i es torna a analitzar a cada predicat. Això permet que els filtres de metadades (search_kwargs["filter"]) els avaluï la base de dades en lloc de fer-ho per força bruta. El filtratge de metadades era la lliçó de la part 4 segons la qual la proximitat semàntica no equival a la correcció temàtica; use_jsonb=True és l'interruptor que manté aquesta lliçó assequible a Postgres. Apareix en totes les crides PGVector(...) del capítol. Continua escrivint-lo — tot i que cal tenir present que, al langchain-postgres actual, l'argument ha esdevingut vestigial: passar use_jsonb=False ara provoca NotImplementedError, perquè es va eliminar el camí de JSON simple.
La correcció: passa embedding_length=1536. El curs no ho fa mai, i la conseqüència és tot el problema del pas 9. La documentació interna de la biblioteca ho diu sense embuts: definir la longitud impedeix inserir vectors de mides diferents, «però sense això no es poden indexar els embeddings». Defineix-la en la primera construcció, abans que existeixi la taula, i la columna es crearà com a vector(1536); si te n'oblides, obtindràs una columna vector sense dimensionalitat sobre la qual no es pot crear cap índex ANN.
La prova bàsica té l'estructura correcta, i val la pena posar-li nom com a patró: escriure → tornar a llegir → verificar → eliminar. Els fotogrames mostren la seqüència de crides, però no tot el cos de la funció; aquesta és la seqüència desenvolupada.
# 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
Sortida esperada en una execució correcta: 🔗 Connecting to Supabase… / Host: db.<ref>.supabase.co / ✅ Connected!. El formador l'executa dues vegades — primer amb neteja, després amb l'eliminació comentada perquè quedi una fila per observar-la al tauler 03:46:09. És un recurs didàctic, no un patró: mantén la neteja. Una prova bàsica que deixa residus és una prova que deixaràs d'executar contra producció.
Pas 6 — Mira l'esquema que LangChain t'ha creat
Actualitza Database → Tables. Ara hi ha dues taules que no has escrit tu 03:46:09, 03:51:40, 03:53:35:
| Taula | Columnes | Funció |
|---|---|---|
langchain_pg_collection | 3: uuid, name, cmetadata | una fila per col·lecció lògica; name és el collection_name que has passat a Python |
langchain_pg_embedding | 5: id, collection_id, embedding, document, cmetadata | una fila per fragment: el vector, el text original, les metadades i una clau forana cap a la seva col·lecció |
embedding conté els valors vector de pgvector — en pantalla es mostren truncats, com ara [0.010925293, -0.0…], [-0.057647705, 0.0…], [-0.075805664, 0.0…]. El uuid de la col·lecció és un UUID real de Postgres (693b2e31-0d86-4b03-9998-43b67d2c3f1… en pantalla); l'id de la fila de l'embedding és una clau primària de tipus cadena que casualment conté un UUID (c2d2b085-5c61-40db-b762-4df9e6a35ebb) — per això pots proporcionar identificadors estables propis a add_documents i fer que la reingesta sigui idempotent. La clau forana collection_id → langchain_pg_collection.uuid està declarada amb ON DELETE CASCADE.
D'això se'n desprenen directament dues conseqüències, i totes dues són d'aquelles coses que només aprens després d'haver-te cremat:
- Eliminar una col·lecció no redueix l'índex de la taula. Les files desapareixen (per la cascada), però l'inflament de l'índex es manté fins a un
REINDEXo unVACUUM FULL. En un pla gratuït de 500 MB, això importa. - La multitenència per col·lecció no és aïllament. Si la separació entre clients és un requisit, fes servir projectes o bases de dades separats, o una política RLS real sobre
cmetadata, no diferentscollection_name.
Pas 7 — L'estructura de producció: un objecte de configuració i una classe de servei
El segon fitxer que repassa el curs, 03_production_example.py, és el que val la pena interioritzar — no perquè el seu RAG sigui bo (explícitament no ho és), sinó perquè l'estructura és correcta.
«Això no és necessàriament un sistema RAG optimitzat, sinó que serveix per mostrar-vos com fer servir pgvector de Supabase.» 03:48:13
L'estructura és: una @dataclass Config que conté tots els paràmetres ajustables, i una classe de servei que conté el magatzem inicialitzat sota demanda i les quatre operacions que l'aplicació necessita realment.
La reconstrucció de Config + RAGService (a partir dels fotogrames de 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 d'aquests mètodes no es poden executar tal com estan reconstruïts, i els has de corregir a la teva còpia en lloc de suposar que els fotogrames eren complets. ask() crida self.chain, que res del que es veu en pantalla no assigna — dona a la classe una segona propietat inicialitzada sota demanda que memoritzi _create_chain(), seguint el patró de vectorstore. ask_with_sources() itera sobre docs_with_scores, un nom que no és a l'àmbit — primer ha de cridar self.search(question) i construir la resposta a partir d'aquells mateixos documents; altrament, les citacions que retorna no tenen relació amb la resposta que retorna. El segon error és el més perillós: unes citacions que no corresponen al context recuperat són pitjors que no tenir-ne, perquè semblen acreditar la procedència i no ho fan.
Els valors de configuració, verificats en pantalla a 03:47:40 i 03:48:05:
| Camp | 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 |
Quatre coses que cal retenir d'aquest fitxer:
La inicialització sota demanda és el detall fonamental. vectorstore és una @property protegida amb if self._vectorstore is None: 03:48:25. Per tant, construir RAGService() no obre cap sòcol ni crea cap client d'OpenAI — cosa que permet importar el mòdul en una prova unitària, instanciar-lo a l'àmbit del mòdul de FastAPI o passar-lo a un procés de treball que pot gestionar una tasca que no recuperi mai res. El moment d'importació no és el primer ús, i només el segon t'hauria de costar una connexió a la base de dades.
La cadena és la *mateixa* cadena LCEL de la part 1. {"context": retriever | format_docs, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser() és l'estructura exacta de rag_pipeline.py (línies 110–113). L'allotjament no l'ha afectada en res. És la promesa de portabilitat feta realitat.
search() exposa deliberadament el filtratge de metadades — «una mica de filtratge de metadades per fer més rellevants els documents recuperats» 03:49:15 — i retorna tuples (Document, score) en lloc de documents sols, de manera que qui el crida pot veure com n'era de bona la coincidència. Totes dues decisions són les que fan possible ask_with_sources.
min_similarity: float = 0.5 es declara i, en pantalla, no es fa servir mai. Cap camí del codi no el llegeix. Digues-ho clarament en lloc de fingir que és un llindar funcional — i si l'implementes tu, recorda l'advertiment de la part 4: similarity_search_with_score a PGVector retorna una *distància*, no una similitud. Amb l'estratègia de cosinus per defecte, com més baix, millor. Un llindar calibrat amb Chroma no és transferible, i un if score > 0.5: keep ingenu conservarà precisament les pitjors coincidències. Torna a deduir-lo imprimint puntuacions sobre un corpus que coneguis.
Pas 8 — Executa-ho i verifica-ho al tauler
Primer elimina les files que hagin quedat de la prova bàsica, perquè el recompte que estàs a punt de llegir tingui sentit. Despré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 answerActualitza el tauler: langchain_pg_collection té una fila anomenada production_documents; langchain_pg_embedding té 3 registres, cadascun amb el text del document, un vector i les metadades topic / source conservades a cmetadata 03:50:17, 03:53:35. L'ordre de les files és arbitrari — «l'ordre no importa gaire».
Pas 9 — Dona un índex ANN a la taula
Aquest pas no surt al curs, i és la diferència entre una demostració i un sistema. Comença confirmant a la teva base de dades els dos fets del requadre del pas 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 tipus retornat és simplement vector, t'has saltat embedding_length= i la columna no té dimensionalitat. Crear-hi un índex falla amb aquest error literal de pgvector: column does not have dimensions. Corregeix la taula existent sense recrear-la i després crea l'índex:
-- 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;
Fes servir vector_cosine_ops tret que hagis canviat distance_strategy=: el valor per defecte de PGVector és DistanceStrategy.COSINE, de manera que les consultes generen <=>. Un índex creat amb una classe d'operadors incorrecta senzillament no es fa servir mai, i res no t'avisa — la latència es queda exactament com estava.
Aquestes xifres no són arbitràries. Són la taula de configuracions predefinides de la part 8 03:16:04–03:17:04 i els valors del codi de pgvector que el curs mostra per a cadascuna 03:17:04–03:18:05:
| Règim | m | ef_search | Prioritat |
|---|---|---|---|
| Prototip | 16 | 40 | Velocitat |
| Producció | 16 | 100 | Equilibri |
| Alta precisió | 32 | 200 | Precisió |
Llegeix aquesta taula al costat dels valors per defecte de pgvector — m = 16, ef_construction = 64, hnsw.ef_search = 40 — i es redueix a una cosa que pots recordar: la configuració de «prototip» és simplement pgvector tal com ve, i passar a producció vol dir apujar una variable de sessió de 40 a 100. El repartiment de funcions ho fa manejable: m i ef_construction són de temps de construcció i requereixen reconstruir l'índex per canviar-los; ef_search és de temps de consulta i pots experimentar-hi lliurement. Si falta sensibilitat de recuperació, apuja primer ef_search. Paga la reconstrucció de l'índex i la RAM addicional d'un m superior només quan ef_search tot sol no sigui suficient.
pgvector també inclou un tipus d'índex IVFFlat que el curs no esmenta mai. Es construeix molt més de pressa i consumeix molta menys memòria que HNSW, però té tres punts delicats: s'ha de construir després que la taula contingui dades (agrupa els vectors que pot veure), el paràmetre lists s'ha de dimensionar segons el nombre de files (rows / 1000 fins a 1M de files, sqrt(rows) a partir d'aquí) i el paràmetre de consulta ivfflat.probes té un valor per defecte d'1, que dona una sensibilitat de recuperació pèssima fins que l'apuges (comença al voltant de sqrt(lists)). La sensibilitat també decau a mesura que insereixes dades més enllà del punt en què es va entrenar. HNSW és més lent i exigent de construir, i és l'opció per defecte correcta per a un corpus que continua creixent — és a dir, qualsevol corpus RAG. Recorre a IVFFlat només quan el temps de construcció de l'índex o la RAM siguin la restricció determinant.
Si prefereixes controlar directament l'esquema — cosa que hauries de fer quan el sistema sigui important —, la versió escrita a mà és petita. Les lliçons locals anteriors de pgvector del curs en construeixen una de semblant a l'SQL Editor (esmentades a 03:50:17, fora d'aquest capítol):
-- 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) d'aquest DDL és la invariant 2 escrita com a restricció a l'esquema. Canvia el model d'embeddings i la mateixa base de dades rebutjarà la inserció — que és exactament la fallada explícita que vols, en lloc de la fallada silenciosa de mateixa dimensionalitat però model diferent de la part 4.
El tauler de Supabase també mostra un botó Index Advisor a la vista de taula 03:53:35. El curs no el clica mai. Val la pena mirar-lo en una taula amb trànsit real, però raona sobre índexs convencionals de Postgres i no substitueix l'elecció dels teus propis paràmetres ANN.
Pas 10 — Activa la seguretat a escala de fila — a totes dues taules
Obre el Table editor. Les dues taules acabades de crear per LangChain porten una etiqueta vermella UNRESTRICTED i un botó «RLS disabled». Passa-hi el cursor:
«Qualsevol persona pot accedir a aquesta taula mitjançant la Data API perquè l'RLS està desactivada.» 03:53:25
És la conseqüència de la casella del pas 1. La Data API està activada i l'RLS desactivada; per tant, qualsevol persona que tingui la clau publicable pot llegir tots els documents i vectors del magatzem — el teu corpus, el text dels clients i tot el que els embeddings hi codifiquen.
Solució, per a cada taula: clica l'etiqueta → View policies → Enable RLS → confirma «Are you sure you want to enable Row Level Security on this table?» → Enable. Després repeteix-ho a la segona taula 03:54:27. Activar l'RLS a langchain_pg_collection no fa res per a langchain_pg_embedding. L'etiqueta desapareix quan totes dues estan fetes.
L'equivalent SQL, que és el que realment hauries de posar en una migració perquè no sigui una cosa que algú s'oblidi de fer:
-- 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;
«Sempre hauríeu d'activar l'RLS. Així les dades estan protegides.» 03:53:25
Els compromisos operatius que acabes d'assumir
El plantejament del capítol és «no t'has de preocupar de res» 03:34:19. És llenguatge comercial, i fins i tot la demostració de la mateixa font ho contradiu al cap de quinze minuts. L'allotjament gestionat elimina les operacions del servidor. No elimina les decisions de base de dades. Aquesta és la llista honesta del que ara et correspon.
| Ja no és responsabilitat teva | Ara és responsabilitat teva |
|---|---|
Pedaços del sistema operatiu, pg_upgrade, aprovisionament de disc | Disseny de l'esquema, dimensionalitat de la columna vectorial i paràmetres de l'índex (m, ef_construction, ef_search) |
| Cron de còpies de seguretat, configuració de la replicació i de la commutació per error | Mode d'agrupació de connexions — directe, per transacció o per sessió |
| Planificació de capacitat del maquinari | El límit d'emmagatzematge de 500 MB / 8 GB i què hi compta |
| Seguretat física | RLS, per taula, a cada desplegament |
| Enginyeria de disponibilitat | Trànsit de sortida (5 GB gratuïts) i el cost de retornar el text de document a cada consulta |
| — | Latència de xarxa entre l'aplicació i la base de dades, que ara és una xifra real dins del teu p95 |
| — | Superfície de dependència del proveïdor: quina part de la plataforma de Supabase (autenticació, Data API, Edge Functions) adoptes |
L'agrupació de connexions és la mancança real més gran de la font. La dataclass Config porta el comentari # Database - use pooler URL in production 03:47:40 — per tant, el curs sap que importa —, i el fitxer que ho explicaria, 02_connection_pooling.py, se salta explícitament: «Em salto l'agrupació de connexions perquè és una cosa que podeu investigar» 03:46:09. No s'ensenya enlloc més. Omple tu aquest buit, perquè és la fallada que fa caure sota càrrega un servei RAG que funcionava:
- Les connexions Postgres són costoses i limitades. Una instància gestionada petita pot admetre'n desenes, no milers. Cada procés de treball d'uvicorn, cada invocació de Lambda i cada tasca en segon pla que construeix un
PGVectorn'obre una — iPGVectorcrea un motor SQLAlchemy nou, amb la seva pròpia agrupació, per cada cadena DSN que li passes. Construeix el magatzem una vegada per procés, o passa unEnginecompartit com aconnection=en lloc d'una cadena. - Un servei de llarga durada (VM, contenidor, FastAPI darrere d'uvicorn) ha de fer servir la connexió directa més aquesta agrupació a l'aplicació, dimensionada segons el nombre de processos de treball — no una connexió per petició.
- Un desplegament serverless ha de fer servir el transaction pooler, perquè no hi ha cap procés que mantingui una connexió entre invocacions, i mil arrencades en fred simultànies esgotarien altrament les connexions disponibles del servidor i començarien a retornar errors als usuaris. Tingues present la restricció associada: l'agrupació en mode transacció no conserva estat de sessió, de manera que un simple
SET hnsw.ef_search = …no sobreviurà fins a la instrucció següent. Fes servirSET LOCAL hnsw.ef_search = 100dins de la transacció que executa la consulta, o defineix el valor per defecte del rol o la base de dades ambALTER ROLE … SET. - El Session pooler existeix per una raó: ets en una xarxa només IPv4 i no pots arribar al servidor directe. És una alternativa de compatibilitat, no una estratègia d'escalat.
La latència canvia de naturalesa. Una consulta a Chroma local és una lectura de la memòria cau de pàgines. Una consulta a Supabase és una anada i tornada TCP a una altra regió, amb CPU compartida, més la cerca ANN, més el retorn del text dels fragments per la xarxa. Situa l'aplicació a la mateixa regió que la base de dades. La instrumentació de la part 7 ho fa visible: si el p95 de recuperació es dispara després de la migració, els primers sospitosos són un índex ANN absent, regions diferents i l'establiment d'una connexió a cada petició.
El trànsit de sortida és una partida pressupostària real. 5 GB gratuïts. Cada recuperació retorna text de document, no només vectors, i si recuperes k=5 fragments d'uns ~1,000 caràcters per consulta, són ~5 KB per petició abans de la sobrecàrrega. Un milió de peticions són ~5 GB. No és un límit que assoliràs durant el desenvolupament, però l'hauries de poder calcular abans que et sorprengui.
Còpies de seguretat. Postgres gestionat ofereix còpies automàtiques als nivells de pagament, i els gratuïts normalment no ofereixen recuperació a un instant concret. Els vectors són dades derivades — sempre pots regenerar els embeddings a partir dels documents originals —; per tant, allò del qual realment has de fer còpia és el corpus original i el codi d'ingesta, no la base de dades.
Migrar un corpus existent de Chroma
La font no ho cobreix mai — torna a executar una demostració des de zero —, però ho necessitaràs, i és breu. Com que els vectors són dades derivades, només hi ha dues opcions honestes:
- Regenerar els embeddings a partir de la font (recomanat). Executa el pipeline existent de càrrega → divisió → embedding → emmagatzematge amb el constructor de
PGVectoren lloc del deChroma. Cost: una regeneració completa dels embeddings del corpus (ambtext-embedding-3-small, $0.02 per 1M de tokens — prou barat perquè gairebé sempre sigui la resposta correcta). Avantatge: pots corregir el chunking alhora, i saps exactament què hi ha al magatzem nou. - Copiar els vectors. Extreu
documents,embeddings,metadatasiidsde Chroma i insereix-los ambadd_embeddings(), que accepta vectors precalculats i evita la crida d'embedding. Més barat en dòlars, però més fràgil: has de garantir que els vectors es van generar amb el mateix model i la mateixa dimensionalitat, i depens d'una estructura de taules que controla LangChain i que ja ha canviat una vegada.
En qualsevol cas, executa el mateix conjunt de proves de recuperació contra tots dos magatzems abans i després, i compara els identificadors dels documents dels primers k resultats. Una migració que canvia silenciosament què es recupera canvia silenciosament totes les respostes del sistema — i, segons la invariant 4, res no llançarà cap excepció.
Què no cobreix la font, dit clarament
Ser clar sobre els límits del material és més útil que dissimular-los:
- Implementació de l'agrupació de connexions — assenyalada com a important, omesa explícitament 03:46:09, mai explicada.
- Creació de l'índex ANN a la instància allotjada — el curs diu que LangChain «ha creat automàticament alguns índexs» i no els inspecciona mai. No crea cap índex vectorial; el pas 9 existeix per omplir aquest buit.
- L'argument
embedding_length— no s'esmenta mai, i sense ell la columna no es pot indexar de cap manera. - Migració d'un corpus existent — no es cobreix enlloc.
- Còpies de seguretat, PITR, simulacres de restauració — no es cobreixen.
- Polítiques RLS — només es mostra l'activació de l'RLS. Escriure una política real queda fora de l'abast.
- Multitenència — no es tracta; l'abstracció de col·lecció convida a donar-hi una resposta equivocada.
- Pràctica amb Neon i RDS — apareixen en una diapositiva, però no es demostren mai. Tota la interfície del procediment és específica de Supabase; només el DSN i l'SQL són transferibles.
- Comportament de l'arrencada en fred amb escalat a zero — no s'esmenta mai.
Res d'això no és una crítica a la font — ella mateixa ho diu, i la delimitació de l'abast és deliberada:
«Evidentment, això no és un curs de Supabase ni de pgvector… És un curs sobre bases de dades vectorials.» 03:52:22
És una llista de les coses que has d'anar a aprendre en un altre lloc abans que aquesta pila tecnològica serveixi trànsit.
Llista de comprovació: passar un sistema RAG d'una carpeta a una base de dades allotjada
Tria
- Estima el nombre de vectors i situa'l a l'escala: <100K → el local encara va bé; 100K–10M → pgvector gestionat; 10M+ → considera l'allotjament propi.
- Tria Supabase per defecte, tret que (a) la càrrega tingui molta inactivitat i les arrencades en fred siguin acceptables → Neon, o (b) l'organització ja treballi en un hiperescalador → RDS / Cloud SQL / AlloyDB.
- Torna a deduir el cost amb les teves xifres. 500 MB gratuïts ≈ desenes de milers de fragments de 1536 dimensions.
- Confirma que pgvector estigui disponible al nivell que contractes i que la dimensionalitat dels embeddings sigui ≤ 2,000 si vols indexar una columna
vector.
Aprovisiona
- Crea l'organització i després el projecte.
- Copia la contrasenya de la base de dades en crear-la. Es mostra una sola vegada. (Recuperació: Database → Settings → Reset database password → Generate → Reset.)
- Tria la regió més propera als servidors de l'aplicació; és pràcticament permanent.
- Marca «Enable automatic RLS» en crear el projecte, o deixa escrit que l'activaràs manualment a totes dues taules de LangChain.
- Activa l'extensió
vector(Database → Extensions, esquemaextensions), encara que Supabase la preinstal·li iPGVectorexecuti elCREATE EXTENSIONpel seu compte.
Connecta
- Connect → pestanya Direct. Tria direct connection per a serveis de llarga durada, transaction pooler per a serverless i session pooler només si no pots sortir d'IPv4.
- Posa el DSN a
.envcom aSUPABASE_DATABASE_URL. Treu els claudàtors[…]del marcador de contrasenya. Confirma el port 5432. Confirma l'identificador del projecte. - Reescriu l'esquema com a
postgresql+psycopg://abans de passar-lo aPGVector, o SQLAlchemy buscarà psycopg2 i fallarà. - No incorporis mai
.enva Git. - Conserva l'alternativa
SUPABASE_DATABASE_URL or DATABASE_URLperquè el mateix codi s'executi contra Postgres local.
Connecta el codi
- Substitueix
Chroma(...)perPGVector(embeddings=…, collection_name=…, connection=…, embedding_length=1536, use_jsonb=True). Fixa't enembeddings=, noembedding=. - Defineix
collection_nameuna sola vegada, aConfig. Dos fitxers amb dos noms creen dues col·leccions. - Mantén el model d'embeddings idèntic al que va construir l'índex local (
text-embedding-3-small, 1536 dimensions). - Inicialitza el magatzem vectorial sota demanda darrere d'una
@propertyi construeix-lo una vegada per procés. - Fes que
ask_with_sourcesciti els documents que realment ha fet servir per respondre — una sola recuperació, reutilitzada. - Prova bàsica: afegir → cercar → verificar → eliminar. Mantén la neteja.
Reforça
- Inspecciona l'esquema:
langchain_pg_collection(3 columnes) ilangchain_pg_embedding(5 columnes). - Comprova
format_type(atttypid, atttypmod)sobreembedding:vectorsense més significa sense dimensionalitat →ALTER … TYPE vector(1536)abans que es pugui indexar res. - Consulta
pg_indexesper a la taula. Espera una clau primària iix_cmetadata_gin, i res sobreembeddingfins que ho creïs. - Crea tu l'índex ANN amb la classe d'operadors corresponent:
USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64), i desprésANALYZE. - Defineix
hnsw.ef_search = 100per a producció (el valor per defecte és 40); apuja'l més si filtres per metadades, i només després tocam. ENABLE ROW LEVEL SECURITYa totes dues taules, en una migració, no a cop de clic.- Dimensiona l'agrupació de connexions segons el nombre de processos de treball; no obris una connexió per petició. Amb un transaction pooler, fes servir
SET LOCALper als paràmetres GUC de sessió.
Verifica
- Executa les mateixes proves de recuperació contra el magatzem antic i el nou, i compara els identificadors dels documents dels primers k resultats.
- Torna a mesurar el p95 de recuperació (instrumentació de la part 7). Si ha empitjorat, investiga l'índex, després la regió i després l'agrupació de connexions, en aquest ordre.
- Torna a deduir qualsevol llindar de similitud a partir de les puntuacions de pgvector — són distàncies de cosinus, de manera que com més baix, millor, i res no es transfereix de Chroma.
- Confirma el marge que et queda d'emmagatzematge, trànsit de sortida i connexions, i anota la xifra que desencadenarà el pas a un nivell superior.
Després ves a la part 9 i posa la memòria cau d'embeddings i la de respostes davant de tot això, perquè la consulta més barata a una base de dades allotjada és la que no envies mai.