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

Why this integration matters

If you're building AI for investment banking, you need two things to work together: a model orchestration layer and a durable system of record. LangChain gives you the agent and retrieval layer; PostgreSQL gives you transactional storage for deals, entities, prompts, audit logs, and model outputs.

This combo is what lets you build production systems that can answer questions like “show me all live mandates for EMEA tech clients” or “summarize the latest deal notes for this issuer” without losing traceability.

Prerequisites

• •Python 3.10+
• •PostgreSQL 14+
• •A running PostgreSQL database with credentials
• •pip installed
• •LangChain packages:
  • •langchain
  • •langchain-community
  • •langchain-openai or your preferred LLM provider package
• •PostgreSQL driver:
  • •psycopg2-binary
• •Environment variables configured:
  • •OPENAI_API_KEY
  • •DATABASE_URL or individual DB connection fields
• •A schema ready for banking data, for example:
  • •clients
  • •deals
  • •research_notes
  • •agent_runs

Integration Steps

1. •Install the dependencies.

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

2. •Set up the PostgreSQL connection.

Use SQLAlchemy under the hood so LangChain can talk to Postgres cleanly in production.

import os
from sqlalchemy import create_engine, text

DATABASE_URL = os.getenv("DATABASE_URL", "postgresql+psycopg2://bank_user:bank_pass@localhost:5432/investment_banking")

engine = create_engine(DATABASE_URL, pool_pre_ping=True)

with engine.connect() as conn:
    result = conn.execute(text("SELECT current_database(), current_user"))
    print(result.fetchone())

3. •Create a LangChain SQL toolkit over PostgreSQL.

This is the core bridge: LangChain can inspect schema and run SQL against Postgres through the database wrapper.

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

db = SQLDatabase.from_uri(DATABASE_URL)

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

agent = create_sql_agent(
    llm=llm,
    db=db,
    verbose=True,
    agent_type="openai-tools"
)

4. •Add investment banking context with a schema-backed query.

In banking systems, you do not want free-form answers from the model alone. You want it to query approved tables and return grounded results.

query = """
Show me all active deals in the technology sector above $100M enterprise value.
"""

response = agent.invoke({"input": query})
print(response["output"])

If you want tighter control, use explicit SQL through LangChain’s database object instead of letting the agent guess too much.

sql = """
SELECT deal_name, client_name, sector, enterprise_value_usd, status
FROM deals
WHERE sector = 'Technology'
  AND enterprise_value_usd > 100000000
  AND status = 'Active'
ORDER BY enterprise_value_usd DESC;
"""

rows = db.run(sql)
print(rows)

5. •Persist agent runs and outputs back into PostgreSQL.

For production AI in banking, every interaction should be auditable. Store prompts, responses, timestamps, and metadata so compliance teams can review behavior later.

from datetime import datetime

with engine.begin() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS agent_runs (
            id SERIAL PRIMARY KEY,
            created_at TIMESTAMP NOT NULL DEFAULT NOW(),
            user_prompt TEXT NOT NULL,
            model_output TEXT NOT NULL
        )
    """))

prompt = "Summarize active technology deals above $100M EV."
result = agent.invoke({"input": prompt})

with engine.begin() as conn:
    conn.execute(
        text("""
            INSERT INTO agent_runs (user_prompt, model_output)
            VALUES (:prompt, :output)
        """),
        {"prompt": prompt, "output": result["output"]}
    )

Testing the Integration

Run a simple end-to-end check: connect to Postgres, query data through LangChain, then write an audit row back to the database.

test_prompt = "List all active deals in technology above $100M EV."
result = agent.invoke({"input": test_prompt})

print("MODEL OUTPUT:")
print(result["output"])

with engine.connect() as conn:
    audit_count = conn.execute(text("SELECT COUNT(*) FROM agent_runs")).scalar()
    print(f"Audit rows: {audit_count}")

Expected output:

MODEL OUTPUT:
...
Audit rows: 1

If the output contains grounded deal names and your audit table increments correctly, the integration is working.

Real-World Use Cases

• •Deal desk copilot that answers questions from live Postgres deal tables and logs every response for compliance review.
• •Research assistant that summarizes issuer notes stored in PostgreSQL and generates banker-ready briefing docs through LangChain.
• •Internal ops agent that routes requests like “find all pending KYC items for active mandates” by querying structured banking data directly.

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.