How to Integrate LangChain for retail banking with Twilio for RAG

When you combine LangChain for retail banking with Twilio, you get a practical RAG layer that can answer customer questions over bank policy, product docs, and account context, then deliver the response over SMS or WhatsApp. That matters because retail banking support lives in channels customers already use, while the retrieval layer keeps answers grounded in approved internal knowledge.

Prerequisites

• •Python 3.10+
• •A LangChain-based retail banking app with:
  • •document loaders
  • •embeddings
  • •a vector store
  • •a chat model
• •A Twilio account with:
  • •ACCOUNT_SID
  • •AUTH_TOKEN
  • •a Twilio phone number or WhatsApp sender
• •Access to your banking knowledge base:
  • •product FAQs
  • •fee schedules
  • •card dispute policies
  • •branch/service hours
• •Environment variables set locally or in your deployment platform:
  • •TWILIO_ACCOUNT_SID
  • •TWILIO_AUTH_TOKEN
  • •TWILIO_PHONE_NUMBER
• •Install the Python packages:

pip install langchain langchain-openai langchain-community faiss-cpu twilio python-dotenv flask

Integration Steps

1) Build the retail banking RAG index

Start by loading approved banking documents and storing them in a vector database. In production, keep this corpus tightly scoped to policy and product content that compliance has signed off on.

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

loader = TextLoader("banking_faq.txt", encoding="utf-8")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=120)
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 retrieval to a chat model

Use a retrieval chain so every answer is grounded in retrieved bank content. For retail banking, keep the prompt strict: no invented rates, no unsupported policy claims, and no account-specific actions unless you have authenticated customer context.

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

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a retail banking assistant. Answer only from retrieved bank documents. If the answer is not in the context, say you do not know."),
    ("human", "{input}\n\nContext:\n{context}")
])

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

3) Add Twilio messaging for customer delivery

Twilio handles the outbound channel. In this pattern, your agent receives an SMS/WhatsApp question, runs retrieval through LangChain, then sends the grounded answer back through Twilio’s REST API.

import os
from twilio.rest import Client

twilio_client = Client(
    os.environ["TWILIO_ACCOUNT_SID"],
    os.environ["TWILIO_AUTH_TOKEN"]
)

def send_sms(to_number: str, body: str):
    message = twilio_client.messages.create(
        body=body,
        from_=os.environ["TWILIO_PHONE_NUMBER"],
        to=to_number
    )
    return message.sid

4) Connect inbound Twilio messages to the RAG chain

Expose a webhook endpoint for Twilio. When a customer texts your number, Twilio posts the message payload to your app. Your handler extracts the user question, runs rag_chain.invoke(), then replies using messages.create().

from flask import Flask, request, Response

app = Flask(__name__)

@app.post("/twilio/inbound")
def inbound_sms():
    user_text = request.form.get("Body", "").strip()
    from_number = request.form.get("From", "")

    result = rag_chain.invoke({"input": user_text})
    answer = result["answer"]

    send_sms(from_number, answer)

    return Response("", status=200)

if __name__ == "__main__":
    app.run(port=5000)

If you want immediate SMS responses instead of async follow-up messages, return TwiML directly with MessagingResponse. That works well for short answers and reduces round trips.

from twilio.twiml.messaging_response import MessagingResponse

@app.post("/twilio/inbound-sync")
def inbound_sms_sync():
    user_text = request.form.get("Body", "").strip()
    result = rag_chain.invoke({"input": user_text})

    response = MessagingResponse()
    response.message(result["answer"])
    return Response(str(response), mimetype="application/xml")

Testing the Integration

Use a local test first before wiring Twilio webhooks in production. This verifies that retrieval works and that your messaging function can deliver the output.

test_question = "What is the cash withdrawal fee on international ATMs?"
result = rag_chain.invoke({"input": test_question})

print("ANSWER:", result["answer"])

# Optional: simulate outbound delivery
sid = send_sms("+15551234567", result["answer"])
print("TWILIO SID:", sid)

Expected output:

ANSWER: International ATM withdrawal fees are listed as ...
TWILIO SID: SMXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

If the answer comes back vague or unsupported, check these first:

• •your documents are actually loaded into FAISS
• •chunking isn’t too aggressive
• •the retriever returns relevant chunks with k=4 or higher if needed
• •your system prompt forbids hallucinated answers

Real-World Use Cases

• •Retail banking FAQ bot over SMS
  • •Customers ask about card replacement fees, transfer limits, branch hours, and dispute timelines by text.
• •Authenticated account-service assistant
  • •After identity verification upstream, combine customer context with RAG to explain overdraft rules or payment posting times.
• •Collections and notifications
  • •Use Twilio to send policy-grounded reminders about due dates, while LangChain generates compliant responses to follow-up questions.

The clean pattern here is simple: LangChain handles retrieval and grounded generation; Twilio handles customer delivery. Keep those responsibilities separate, keep the knowledge base curated, and you’ll avoid most of the failure modes that show up in regulated banking workflows.

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.