How to Integrate LangChain for pension funds with Slack for RAG

Combining LangChain for pension funds with Slack gives you a practical RAG interface where staff can ask questions in the channel they already use, and the agent can answer from policy docs, fund rules, investment memos, and operational runbooks. The useful part is not chat for chat’s sake; it’s turning Slack into a retrieval front-end for controlled, auditable pension knowledge.

Prerequisites

• •Python 3.10+
• •A Slack workspace with:
  • •an app created in the Slack API dashboard
  • •bot token
  • •signing secret
  • •permissions to read messages and post replies
• •Access to your pension fund knowledge sources:
  • •PDFs, policy docs, committee minutes, benefit rules, FAQs
• •LangChain installed with your chosen LLM and vector store packages
• •An embeddings provider configured, such as OpenAI or Azure OpenAI
• •A vector database or local store:
  • •FAISS for local testing
  • •Pinecone, Weaviate, or pgvector for production
• •Environment variables set:
  • •SLACK_BOT_TOKEN
  • •SLACK_SIGNING_SECRET
  • •OPENAI_API_KEY

Integration Steps

1. •Build the pension fund retrieval layer first.

You want the retriever isolated before Slack enters the picture. That keeps your RAG pipeline testable and lets you tune chunking, embeddings, and search quality without touching the bot.

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS

loader = PyPDFLoader("pension_fund_policy.pdf")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
chunks = splitter.split_documents(docs)

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = FAISS.from_documents(chunks, embeddings)

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

2. •Wire LangChain’s retrieval chain to an LLM.

Use a retrieval chain that takes a question and returns grounded answers from your pension documents. For production, keep prompts strict: answer only from retrieved context and say when the answer is not in the source material.

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a pension fund 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)

3. •Set up Slack event handling with Bolt.

Slack should send messages to your app, and your app should respond in-thread. This gives you traceability per conversation and avoids noisy channel-wide replies.

import os
from slack_bolt import App

app = App(
    token=os.environ["SLACK_BOT_TOKEN"],
    signing_secret=os.environ["SLACK_SIGNING_SECRET"]
)

@app.event("app_mention")
def handle_mention(event, say):
    user_text = event.get("text", "")
    result = rag_chain.invoke({"input": user_text})
    answer = result["answer"]
    say(text=answer, thread_ts=event["ts"])

4. •Post grounded answers back into Slack.

For better operator experience, include source citations or document names in the response. That makes it easier for compliance teams to verify where an answer came from.

@app.event("message")
def handle_message(event, say):
    if event.get("bot_id"):
        return

    text = event.get("text", "")
    if not text.startswith("pension:"):
        return

    query = text.replace("pension:", "", 1).strip()
    result = rag_chain.invoke({"input": query})

    sources = []
    for doc in result["context"]:
        source = doc.metadata.get("source", "unknown")
        sources.append(f"- {source}")

    response = f"{result['answer']}\n\nSources:\n" + "\n".join(sources)
    say(text=response)

5. •Run the Slack app and expose it to Slack events.

If you’re testing locally, use ngrok or another tunnel so Slack can reach your Flask/FastAPI/Bolt endpoint. In production, deploy behind HTTPS with proper secret handling and log redaction.

if __name__ == "__main__":
    app.start(port=int(os.environ.get("PORT", 3000)))

Testing the Integration

Send a test question in Slack like:

• •pension: What is the vesting period for employer contributions?

Then confirm your bot replies in-thread with a grounded answer.

test_query = "What is the vesting period for employer contributions?"
result = rag_chain.invoke({"input": test_query})

print(result["answer"])
print("\nRetrieved docs:")
for doc in result["context"]:
    print(doc.metadata.get("source"), doc.page_content[:120])

Expected output:

Employer contributions vest after 3 years of service under Section 4.2 of the plan document.

Retrieved docs:
pension_fund_policy.pdf Page 12 ...
benefits_faq.pdf Page 3 ...

If you get vague answers or no citations:

• •reduce chunk size if documents are too dense
• •increase k from 4 to 6 for broader retrieval
• •tighten the system prompt so it refuses unsupported claims
• •verify Slack events are reaching your server

Real-World Use Cases

• •Benefits operations assistant
  • •Staff ask about eligibility rules, contribution vesting, retirement age thresholds, or hardship withdrawal policy directly from Slack.
• •Committee memo search
  • •Investment teams query prior minutes and policy papers during meetings without leaving their workflow.
• •Member services triage
  • •Support agents use Slack to get fast answers grounded in official pension documents before responding to escalations.

The pattern here is simple: LangChain handles retrieval and answer generation, Slack handles distribution and workflow entry. Keep them loosely coupled so you can swap models, change vector stores, or add approval steps later without rewriting the bot.

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.