How to Integrate LangChain for investment banking with PostgreSQL for AI agents

Combining LangChain for investment banking with PostgreSQL gives you a practical setup for building AI agents that can reason over deal data, retrieve firm knowledge, and persist conversation state or audit trails. In banking workflows, that means your agent can answer questions about pitch books, transaction history, market comps, and internal policies without losing context between calls.

The useful part is not just retrieval. PostgreSQL gives you durable storage for structured data, while LangChain handles orchestration, tool use, and retrieval patterns around that data.

Prerequisites

• •Python 3.10+
• •PostgreSQL 14+
• •A running PostgreSQL database with credentials
• •pip or uv for dependency management
• •An OpenAI API key or another supported LLM provider
• •Basic familiarity with SQLAlchemy and Python async/sync database access
• •Installed packages:
  • •langchain
  • •langchain-openai
  • •langchain-community
  • •psycopg2-binary
  • •sqlalchemy

Integration Steps

1. •

   Install the dependencies

   Start by installing the core packages for LangChain and PostgreSQL connectivity.

   pip install langchain langchain-openai langchain-community psycopg2-binary sqlalchemy
   

2. •

   Create the PostgreSQL connection string

   Use a proper SQLAlchemy URL so LangChain can talk to PostgreSQL through the standard database layer.

   import os
   
   POSTGRES_USER = os.getenv("POSTGRES_USER", "bank_user")
   POSTGRES_PASSWORD = os.getenv("POSTGRES_PASSWORD", "bank_pass")
   POSTGRES_HOST = os.getenv("POSTGRES_HOST", "localhost")
   POSTGRES_PORT = os.getenv("POSTGRES_PORT", "5432")
   POSTGRES_DB = os.getenv("POSTGRES_DB", "investment_bank")
   
   DATABASE_URL = (
       f"postgresql+psycopg2://{POSTGRES_USER}:{POSTGRES_PASSWORD}"
       f"@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DB}"
   )
   

3. •

   Initialize the LangChain model and PostgreSQL-backed store

   For an agent system, you usually want both a chat model and a persistent store. Here’s a minimal setup using LangChain’s OpenAI wrapper and SQLAlchemy engine.

   from sqlalchemy import create_engine
   from langchain_openai import ChatOpenAI
   
   engine = create_engine(DATABASE_URL)
   
   llm = ChatOpenAI(
       model="gpt-4o-mini",
       temperature=0,
       api_key=os.environ["OPENAI_API_KEY"],
   )
   
   print(engine)
   print(llm.model_name)
   

4. •

   Create a table for agent memory or deal notes

   In investment banking workflows, you want to persist things like client preferences, deal stage, compliance flags, or analyst notes. This example creates a simple table for agent memory.

    from sqlalchemy import text
   
    with engine.begin() as conn:
        conn.execute(text("""
            CREATE TABLE IF NOT EXISTS agent_memory (
                id SERIAL PRIMARY KEY,
                session_id TEXT NOT NULL,
                role TEXT NOT NULL,
                content TEXT NOT NULL,
                created_at TIMESTAMP DEFAULT NOW()
            )
        """))
   
        conn.execute(text("""
            CREATE INDEX IF NOT EXISTS idx_agent_memory_session_id
            ON agent_memory(session_id)
        """))
   

5. •

   Wire LangChain to read from PostgreSQL and answer queries

   Use PostgreSQL as the source of truth and let LangChain generate answers based on retrieved rows. This pattern works well for structured banking data like deals, counterparties, or pipeline records.

   from langchain_community.utilities import SQLDatabase
   from langchain.chains import create_sql_query_chain
   
   db = SQLDatabase(engine)
   
   sql_chain = create_sql_query_chain(llm, db)
   
   question = "Which deals in the pipeline are in diligence stage?"
   sql_query = sql_chain.invoke({"question": question})
   
    print(sql_query)
   

Testing the Integration

Run a simple end-to-end check: insert one record into PostgreSQL, then ask LangChain to generate a query against it.

from sqlalchemy import text

session_id = "deal_team_001"

with engine.begin() as conn:
    conn.execute(
        text("""
            INSERT INTO agent_memory (session_id, role, content)
            VALUES (:session_id, :role, :content)
        """),
        {
            "session_id": session_id,
            "role": "analyst",
            "content": "Client prefers debt financing over equity.",
        },
    )

with engine.connect() as conn:
    result = conn.execute(
        text("SELECT role, content FROM agent_memory WHERE session_id = :session_id"),
        {"session_id": session_id},
    ).fetchall()

print(result)

Expected output:

[('analyst', 'Client prefers debt financing over equity.')]

If you want to test the SQL generation path too:

response = sql_chain.invoke({"question": "Show all notes for session deal_team_001"})
print(response)

You should see a SQL query targeting agent_memory, not an empty or malformed response.

Real-World Use Cases

• •

  Deal desk assistant

  • •Retrieve live pipeline data from PostgreSQL.
  • •Let LangChain summarize status updates for bankers before client calls.
• •

  Compliance-aware note assistant

  • •Store analyst notes and compliance flags in PostgreSQL.
  • •Use LangChain to surface only approved language when drafting emails or summaries.
• •

  Investment memo generator

  • •Pull transaction history, market data snapshots, and internal commentary from PostgreSQL.
  • •Have LangChain assemble first-draft memos with traceable source rows.

The pattern that matters here is simple: PostgreSQL holds durable banking data, and LangChain turns that data into agent behavior. Once this is in place, you can extend it with vector search, tool calling, and workflow-specific guardrails without changing your storage layer.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.