How to Integrate LangChain for healthcare with PostgreSQL for RAG

LangChain for healthcare plus PostgreSQL gives you a practical RAG stack for clinical workflows: retrieve patient-facing policies, summarize care guidelines, and answer internal support questions with traceable sources. PostgreSQL handles durable storage and filtering; LangChain for healthcare handles orchestration, retrieval, and generation around regulated medical content.

Prerequisites

• •Python 3.10+
• •A running PostgreSQL 14+ instance
• •A database user with read/write access
• •psycopg2-binary or psycopg installed
• •langchain
• •langchain-community
• •langchain-postgres
• •A healthcare-capable LLM provider configured in LangChain
• •Embeddings model access for vector search
• •Optional: pgvector extension enabled in PostgreSQL

Install the packages:

pip install langchain langchain-community langchain-postgres psycopg2-binary pgvector

Enable the vector extension if you plan to store embeddings in PostgreSQL:

CREATE EXTENSION IF NOT EXISTS vector;

Integration Steps

1. •Create the PostgreSQL schema for documents and embeddings

Start with a table that can hold raw clinical text, metadata, and embedding vectors. If you use pgvector, keep the schema explicit so your retrieval layer stays predictable.

import os
import psycopg2

conn = psycopg2.connect(
    host=os.getenv("POSTGRES_HOST", "localhost"),
    port=os.getenv("POSTGRES_PORT", "5432"),
    dbname=os.getenv("POSTGRES_DB", "rag_healthcare"),
    user=os.getenv("POSTGRES_USER", "postgres"),
    password=os.getenv("POSTGRES_PASSWORD", "postgres"),
)

with conn.cursor() as cur:
    cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
    cur.execute("""
        CREATE TABLE IF NOT EXISTS clinical_docs (
            id SERIAL PRIMARY KEY,
            content TEXT NOT NULL,
            metadata JSONB DEFAULT '{}'::jsonb,
            embedding vector(1536)
        );
    """)
    conn.commit()

conn.close()

2. •Load healthcare documents into PostgreSQL

Use LangChain document loaders to ingest policy PDFs, discharge instructions, or internal care protocols. In production, keep PHI out of this layer unless your compliance controls are already in place.

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = TextLoader("./data/clinical_policy.txt")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=120)
chunks = splitter.split_documents(docs)

for chunk in chunks:
    print(chunk.page_content[:120], chunk.metadata)

If your source is a PDF or HTML knowledge base, swap the loader accordingly. The important part is producing small chunks that are easy to embed and retrieve.

3. •Embed and store chunks in PostgreSQL using LangChain

Use a standard embedding model and persist vectors into Postgres. The PGVector integration from langchain-postgres gives you a clean path for storing and querying embeddings without building custom SQL glue.

from langchain_postgres import PGVector
from langchain_openai import OpenAIEmbeddings

connection_string = "postgresql+psycopg://postgres:postgres@localhost:5432/rag_healthcare"

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vectorstore = PGVector(
    embeddings=embeddings,
    collection_name="clinical_knowledge",
    connection=connection_string,
    use_jsonb=True,
)

vectorstore.add_documents(chunks)

If you want direct SQL control instead of the vector store abstraction, compute embeddings and insert them manually with psycopg. The abstraction is usually enough unless you need custom indexing logic.

4. •Build the retriever and RAG chain

This is where LangChain for healthcare earns its keep. You combine retrieval from Postgres with an LLM prompt that constrains answers to retrieved clinical context.

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains.retrieval import create_retrieval_chain

retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a healthcare assistant. Answer only from the provided context."),
    ("human", "Question: {input}\n\nContext:\n{context}")
])

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

document_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(retriever, document_chain)

For regulated environments, keep temperature at zero and require citations from retrieved chunks. That reduces hallucinations and makes review easier.

5. •Run a query against the integrated system

Now your agent can answer questions by pulling relevant content from PostgreSQL and generating grounded responses.

query = "What is the recommended follow-up after discharge for hypertension patients?"
result = rag_chain.invoke({"input": query})

print(result["answer"])
print("\nSources:")
for doc in result["context"]:
    print(doc.metadata)

If you need an agent workflow instead of a single RAG chain, wrap this retriever inside a tool using create_retriever_tool and let your agent decide when to call it.

Testing the Integration

Run a known question against one of your indexed clinical documents.

test_query = "What should a patient do if they miss a dose of insulin?"
response = rag_chain.invoke({"input": test_query})

print("ANSWER:")
print(response["answer"])

print("\nRETRIEVED CHUNKS:")
for i, doc in enumerate(response["context"], start=1):
    print(f"{i}. {doc.page_content[:150]}")

Expected output:

ANSWER:
If a patient misses an insulin dose, they should follow the clinic’s documented guidance, monitor blood glucose as directed, and contact their care team if symptoms occur.

RETRIEVED CHUNKS:
1. If a dose is missed...
2. Patients should monitor...
3. Contact the clinic...

If the answer comes back empty or generic:

• •Check that documents were inserted into clinical_knowledge
• •Confirm embeddings match the model dimension used by your table
• •Verify the retriever returns relevant chunks with k >= 3
• •Inspect whether your prompt is forcing context-only answers

Real-World Use Cases

• •

  Clinical policy assistant
  Let staff ask questions about medication refill rules, triage steps, or discharge instructions while grounding answers in approved internal documents.

• •

  Patient support agent
  Build an AI agent that answers common post-care questions and retrieves exact guidance from PostgreSQL-backed knowledge bases.

• •

  Compliance-aware medical knowledge search
  Store versioned clinical SOPs in PostgreSQL and use LangChain retrieval to surface only current approved guidance during audits or reviews.

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.