How to Integrate LangChain for healthcare with Twilio for AI agents

Combining LangChain for healthcare with Twilio gives you a practical path to build patient-facing AI agents that can reason over clinical context and reach users where they already are: SMS, voice, or WhatsApp. The useful pattern here is simple: LangChain handles the healthcare workflow and retrieval, while Twilio handles the last-mile communication layer.

Prerequisites

• •Python 3.10+
• •A Twilio account with:
  • •TWILIO_ACCOUNT_SID
  • •TWILIO_AUTH_TOKEN
  • •a Twilio phone number
• •Access to your healthcare data source:
  • •FHIR server, clinical notes store, or approved document repository
• •LangChain installed with your chosen healthcare integrations
• •A supported LLM provider key, such as OpenAI or Azure OpenAI
• •Basic Flask or FastAPI knowledge for receiving Twilio webhooks
• •Environment variables configured in .env

Integration Steps

1. •Set up your project dependencies.

Use LangChain for retrieval and agent orchestration, then add Twilio’s Python SDK for outbound messages and webhook handling.

pip install langchain langchain-openai twilio flask python-dotenv pydantic

If you’re pulling from healthcare records, also install the connector you actually need, such as a FHIR client or vector store integration.

2. •Build the healthcare reasoning layer with LangChain.

A common pattern is to load approved clinical content into a retriever and wrap it in a chain that can answer patient questions safely. Here’s a minimal example using LangChain’s retrieval APIs.

import os
from dotenv import load_dotenv

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document
from langchain.chains import RetrievalQA

load_dotenv()

docs = [
    Document(page_content="Clinic hours: Monday-Friday 8am-5pm."),
    Document(page_content="For urgent symptoms call emergency services immediately."),
    Document(page_content="Prescription refills require 48 hours notice."),
]

splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
chunks = splitter.split_documents(docs)

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

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

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True,
)

In production, replace the toy documents with approved patient education material or de-identified care instructions.

3. •Add Twilio for inbound and outbound messaging.

Twilio will receive patient messages via webhook and send responses back over SMS. The Python SDK uses Client.messages.create(...) for outbound delivery.

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

That messages.create call is the core delivery primitive. Everything else is webhook routing and business logic around it.

4. •Wire the LangChain response into a Twilio webhook.

Your Flask endpoint receives the incoming SMS payload from Twilio, passes the message through the healthcare chain, then returns a TwiML response or sends an outbound SMS directly.

from flask import Flask, request, Response
from twilio.twiml.messaging_response import MessagingResponse

app = Flask(__name__)

@app.route("/sms", methods=["POST"])
def sms_webhook():
    user_text = request.form.get("Body", "").strip()
    from_number = request.form.get("From", "")

    result = qa_chain.invoke({"query": user_text})
    answer = result["result"]

    # Option A: reply directly with TwiML
    resp = MessagingResponse()
    resp.message(answer)

    # Option B: send outbound SMS instead of returning TwiML
    # send_sms(from_number, answer)
    # return ("", 204)

    return Response(str(resp), mimetype="application/xml")

This keeps the integration clean:

• •Twilio handles transport.
• •LangChain handles context retrieval and generation.
• •Your app enforces policy before anything goes out to the patient.

5. •Add basic safety controls before sending anything to patients.

For healthcare workflows, do not forward raw model output blindly. Add a lightweight policy layer that blocks unsafe content and escalates urgent symptoms to a human or emergency guidance.

def postprocess_answer(text: str) -> str:
    blocked_phrases = [
        "diagnose yourself",
        "ignore your symptoms",
        "stop taking medication",
    ]

    lowered = text.lower()
    if any(phrase in lowered for phrase in blocked_phrases):
        return "Please contact your care team for medical guidance."

    return text

@app.route("/sms-safe", methods=["POST"])
def sms_webhook_safe():
    user_text = request.form.get("Body", "").strip()
    result = qa_chain.invoke({"query": user_text})
    safe_answer = postprocess_answer(result["result"])

    resp = MessagingResponse()
    resp.message(safe_answer)
    return Response(str(resp), mimetype="application/xml")

That guardrail is not optional in healthcare. Keep escalation logic explicit and auditable.

Testing the Integration

Run your Flask app locally and expose it with ngrok so Twilio can reach your webhook.

python app.py
ngrok http 5000

Then point your Twilio phone number webhook to:

https://YOUR_NGROK_DOMAIN/sms-safe

Send an SMS like:

What are your clinic hours?

Expected output:

Clinic hours: Monday-Friday 8am-5pm.

If you want to test outbound delivery directly without waiting on an inbound webhook:

print(send_sms("+15551234567", "Your appointment is confirmed for tomorrow at 10am."))

Expected output:

SMXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Real-World Use Cases

• •Appointment support bot that answers scheduling questions over SMS and escalates urgent requests to staff.
• •Medication refill assistant that checks policy-based instructions and texts patients next-step guidance.
• •Post-discharge follow-up agent that asks symptom check questions via Twilio and uses LangChain to route responses based on care protocols.

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.