LangChain versus LlamaIndex voor Postgres-agents

LangChain en LlamaIndex verschenen in dezelfde periode, in de nasleep van de release van ChatGPT eind 2022. Hun uitgangspunt verschilt aanzienlijk. LangChain modelleert een LLM-applicatie als een reeks samenstelbare stappen: prompt, modeloproep, tool, geheugen, allemaal samengesteld via LCEL of een LangGraph-grafiek.

LlamaIndex modelleert eerst gegevens: documenten, knooppunten, indexen, query-engine. Een VectorStoreIndex of SQLDatabase zijn eersteklas burgers, geen hulpmiddelen die aan een generieke agent zijn toegevoegd. Beide zijn open source (MIT-licentie), beschikbaar in Python en TypeScript, en bestrijken tegenwoordig een grotendeels overlappende reikwijdte: agenten, RAG, tooloproep, SQL-verbinding.

Deze convergentie maakt de vergelijking nuttiger voor de architectuur dan voor de lijst met functies: beide kunnen bijna hetzelfde doen. Wat verandert, is hoe.

Aan de LangChain-kant kapselt de langchain_community.utilities.SQLDatabase-module een SQLAlchemy-engine in. De create_sql_agent-agent stelt het vervolgens beschikbaar als een set hulpmiddelen: maak een lijst van tabellen, beschrijf een schema, voer een query uit, controleer een query voordat deze wordt uitgevoerd.

from langchain_community.utilities import SQLDatabase
from langchain_community.agent_toolkits import create_sql_agent
from langchain_openai import ChatOpenAI

# Kanaal verkregen van Studio → Instellingen → Verbinding.
# search_path route naar het projectschema (zie SQLAlchemy/psycopg doc voor
# de exacte codering van de parameter "opties", afhankelijk van het gebruikte stuurprogramma).
db = SQLDatabase.from_uri(
    "postgresql+psycopg2://aura:***@<host>:5432/aura_db_master?options=-csearch_path%3Dproject_<id>"
)

llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_sql_agent(llm=llm, db=db, agent_type="tool-calling")

agent.invoke({"input": "Combien de commandes la semaine dernière ?"})

Aan de LlamaIndex-kant is de equivalente abstractie llama_index.core.SQLDatabase, ook gebouwd op een SQLAlchemy-engine. De NLSQLTableQueryEngine-query-engine vertaalt een vraag in natuurlijke taal naar een SQL-query, voert deze uit en herformuleert het resultaat vervolgens als antwoord.

from sqlalchemy import create_engine
from llama_index.core import SQLDatabase
from llama_index.core.query_engine import NLSQLTableQueryEngine
from llama_index.llms.openai import OpenAI

engine = create_engine(
    "postgresql+psycopg2://aura:***@<host>:5432/aura_db_master?options=-csearch_path%3Dproject_<id>"
)
sql_database = SQLDatabase(engine, include_tables=["orders", "customers"])

query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database, llm=OpenAI(model="gpt-4o-mini"),
)
response = query_engine.query("Combien de commandes la semaine dernière ?")

Geen van beide extracten is afhankelijk van Aurabase. Een SQLAlchemy-stuurprogramma en een standaard Postgres-verbindingsreeks zijn voldoende, net als voor Supabase, RDS of een zelf-gehoste instantie.

LangChain stelde eerst een klassieke agentlus voor (AgentExecutor, ReAct-patroon). Het project heeft sindsdien zijn agenten geconvergeerd naar LangGraph: een agent wordt daar weergegeven als een expliciete grafiek van knooppunten en randen, met controlepunten en mogelijke menselijke tussenkomst tussen twee fasen.

LlamaIndex reageert met zijn Workflows: een gebeurtenisgestuurde orkestratie, waarbij elke stap getypte gebeurtenissen uitzendt en verbruikt. Een SQL- of vectorquery-engine wordt rechtstreeks als stap aangesloten, zonder een extra aanpassingslaag, aangezien deze engine al native primitieven van het raamwerk zijn.

Voor een agent die Postgres opvraagt, is het praktische verschil dit: LangGraph geeft fijnmazige controle over vertakkingen en nieuwe pogingen rond een SQL-aanroep. LlamaIndex vereist minder koppelingscode wanneer de vraag eerst betrekking heeft op gegevens die al door het raamwerk zijn geïndexeerd.

Ga dieper: tutorial voor het aanroepen van functies voor een Postgres-agent

LlamaIndex is vanaf het begin ontworpen om een LLM te verbinden met gegevensbronnen, met een catalogus van connectoren (LlamaHub) en gespecialiseerde indexen, afhankelijk van het type inhoud. RAG blijft de meest directe use-case van het raamwerk, en is geen functie die achteraf is toegevoegd.

LangChain voorziet in dezelfde behoefte via zijn retrievers en ophaalketens, met een even volwassen integratie in het LangGraph-ecosysteem. Het verschil zit minder in de capaciteit dan in waar de bedrijfslogica leeft: geïntegreerd in de index aan de LlamaIndex-kant, expliciet samengevoegd in een keten aan de LangChain-kant.

Beiden weten hoe ze pgvector als vectorbasis moeten gebruiken: llama-index-vector-stores-postgres aan de LlamaIndex-kant, de klasse PGVector van het langchain-postgres-pakket aan de LangChain-kant. Op een Aurabase-project is pgvector 0.8.6 al aanwezig in de Postgres-tenantimage: beide pakketten maken er verbinding mee met dezelfde verbindingsreeks, zonder een afzonderlijke activeringsstap.

Graaf dieper: bouw een Postgres/pgvector RAG-pijplijn

CrewAI orkestreert meerdere agenten per rol: elke agent ontvangt een doelstelling, een context (backstory) en hulpmiddelen, gegroepeerd in Crew, waarbij Task in volgorde of volgens een hiërarchie wordt uitgevoerd. Het is een volwaardig orkestratieframework, geen uitbreiding van LangChain.

AutoGen, een onderzoeksproject van Microsoft, hanteert een andere aanpak: agenten die met elkaar praten (AssistantAgent, UserProxyAgent, GroupChat), met de mogelijkheid om code uit te voeren in een geïsoleerde omgeving. Coördinatie lijkt op een gesprek, en niet op een expliciete toestandsgrafiek zoals LangGraph.

Geen van beide vervangt de dataverbindingslaag. Een CrewAI- of AutoGen-agent die Postgres moet lezen, roept in de praktijk een SQL-tool aan die is gebouwd met LangChain of LlamaIndex, of een eenvoudige Python-functie rond psycopg2. CrewAI en AutoGen antwoorden ‘wie doet wat en in welke volgorde’, niet ‘hoe de database te lezen’.

create_sql_agent en NLSQLTableQueryEngine voeren de door het model gegenereerde query uit op basis van de opgegeven verbinding. Noch beperkt het aantal rijen dat standaard wordt geretourneerd, noch blokkeert een schrijfverzoek: de feitelijke vangrail is de Postgres-rol die wordt gebruikt in de verbindingsreeks, en niet een raamwerkoptie.

Dit is een structureel verschil met de native NL2SQL van Aurabase, die een vraag aan de serverzijde in SQL vertaalt, de gegenereerde query valideert (SQL-parsing, afwijzing van vervalste servervelden) en de LIMIT begrenst vóór uitvoering. Het is niet dezelfde steen: een NL2SQL-eindpunt reageert in één beurt, waarbij vangrails door het platform worden geïnstalleerd; een LangChain- of LlamaIndex-agent redeneert in verschillende fasen, met beveiligingen die u zelf kunt samenstellen.

In de praktijk vullen de twee benaderingen elkaar aan in plaats van elkaar uit te sluiten: een begrensd NL2SQL-eindpunt voor een eenvoudige vraag die aan een eindgebruiker wordt gesteld, een agent voor redeneren in meerdere stappen die verschillende tools naast SQL combineert.

Zie ook: NL2SQL tutorial over Postgres met Aurabase

Drie stappen zijn voldoende, ongeacht het gekozen raamwerk, en ze zijn niet afhankelijk van een platformspecifieke connector.

# 1. Haal de Postgres-verbindingsreeks van het project op
#    (Studio → Instellingen → Verbinding, of een beheerd Postgres)
export AURA_DB_URL="postgresql+psycopg2://aura:***@<host>:5432/aura_db_master?options=-csearch_path%3Dproject_<id>"

# 2. Installeer de SQL-driver en het gekozen framework
pip install langchain langchain-community langchain-openai psycopg2-binary
# of, aan de LlamaIndex-kant:
pip install llama-index llama-index-llms-openai psycopg2-binary

# 3. Maak een speciale Postgres-rol, alleen-lezen als de agent alleen moet pollen
CREATE ROLE agent_readonly LOGIN PASSWORD '***';
GRANT SELECT ON ALL TABLES IN SCHEMA project_<id> TO agent_readonly;

De derde stap is belangrijker dan de keuze van het raamwerk. Een rol van Postgres beperkt tot werkelijk noodzakelijke rechten blijft de enige betrouwbare bescherming tegen een gegenereerd verzoek dat de reikwijdte ervan te boven gaat, ongeacht de agent die het uitvoert. Zie de AI-documentatie voor de configuratie van de native LLM-providers van Aurabase (OpenAI, Anthropic, Gemini) die bruikbaar zijn aan de kant van de agent.

Geen van beide raamwerken is strikt superieur voor een agent die verbonden is met Postgres. De startcontext van het project is bepalender dan de lijst met functionaliteiten.

• LangChain: als de agent verschillende heterogene tools (SQL, externe API's, internetzoekopdrachten) moet combineren met nauwkeurige controle over de stroom via LangGraph, en als het team waarde hecht aan het breedste integratie-ecosysteem op de markt.
• LlamaIndex: als het hart van het project de RAG is of het bevragen van reeds geïndexeerde gegevens, met een sterke behoefte aan bronconnectoren en een index/querymodel dat direct aansluit bij de use case.
• CrewAI of AutoGen daarnaast: zodra een enkele agent niet langer voldoende is en het werk moet worden verdeeld over verschillende gespecialiseerde rollen, boven het ene of het andere van de twee dataframeworks.

De twee kunnen ook naast elkaar bestaan in hetzelfde project: een LlamaIndex-query-engine die als hulpmiddel in een LangGraph-agent wordt weergegeven, is een veel voorkomend patroon. Het handhaven van twee raamwerken brengt reële complexiteitskosten met zich mee, die moeten worden afgewogen tegen de winst voordat deze standaard worden aangenomen.