How to Integrate LangChain for healthcare with Twilio for startups

LangChain for healthcare plus Twilio gives you a practical pattern for patient-facing AI: an agent that can answer clinical workflow questions, summarize intake data, and trigger SMS follow-ups without forcing users into a portal. For startups, this is the fastest way to build a compliant-ish communication layer around a healthcare assistant while keeping the model logic and messaging transport separate.

Prerequisites

• •Python 3.10+
• •A Twilio account with:
  • •ACCOUNT_SID
  • •AUTH_TOKEN
  • •a verified Twilio phone number
• •Access to your healthcare LLM stack:
  • •LangChain installed
  • •a healthcare-capable model or chain
• •Environment variables configured:
  • •TWILIO_ACCOUNT_SID
  • •TWILIO_AUTH_TOKEN
  • •TWILIO_PHONE_NUMBER
  • •OPENAI_API_KEY or your model provider key
• •A basic understanding of:
  • •LangChain chains/agents
  • •Twilio Programmable SMS
  • •PHI handling rules in your environment

Install the packages:

pip install langchain langchain-openai twilio python-dotenv

Integration Steps

1. •Set up configuration and clients

Keep secrets out of code. Load them once, then initialize Twilio and your LangChain model client.

import os
from dotenv import load_dotenv
from twilio.rest import Client as TwilioClient
from langchain_openai import ChatOpenAI

load_dotenv()

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

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

2. •Build the healthcare response chain

For startups, the common pattern is: user message in, structured clinical response out. Use LangChain to turn unstructured patient text into something your workflow can act on.

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", 
     "You are a healthcare assistant for appointment triage and patient messaging. "
     "Do not diagnose. Keep responses concise, safe, and action-oriented."),
    ("user", "{message}")
])

healthcare_chain = prompt | llm

def generate_healthcare_reply(message: str) -> str:
    result = healthcare_chain.invoke({"message": message})
    return result.content.strip()

3. •Send the generated response via Twilio SMS

Twilio’s Python SDK exposes messages.create(), which is the core API call you need for outbound SMS.

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

patient_message = "I have a mild fever and want to reschedule my appointment."
reply = generate_healthcare_reply(patient_message)

sid = send_sms(
    to_number="+15551234567",
    body=f"Thanks for reaching out. {reply}"
)

print("Sent message SID:", sid)

4. •Wrap it in an agent-style workflow

If you want more than one action, put LangChain in control of the conversation and use Twilio as the delivery channel. A simple production pattern is: classify intent, generate response, send SMS, persist audit data.

from datetime import datetime

def process_incoming_patient_text(from_number: str, message_text: str) -> dict:
    reply = generate_healthcare_reply(message_text)

    sid = twilio_client.messages.create(
        body=reply,
        from_=os.environ["TWILIO_PHONE_NUMBER"],
        to=from_number
    ).sid

    return {
        "timestamp": datetime.utcnow().isoformat(),
        "from": from_number,
        "input": message_text,
        "reply": reply,
        "twilio_sid": sid,
        "status": "sent"
    }

5. •Expose it behind a webhook for inbound SMS

Twilio will POST inbound messages to your webhook. Your app receives the text, runs LangChain, then responds through Twilio.

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

app = Flask(__name__)

@app.post("/sms")
def inbound_sms():
    incoming_text = request.form.get("Body", "")
    from_number = request.form.get("From", "")

    reply_text = generate_healthcare_reply(incoming_text)
    process_incoming_patient_text(from_number, incoming_text)

    twiml = MessagingResponse()
    twiml.message(reply_text)
    return Response(str(twiml), mimetype="application/xml")

Testing the Integration

Use a real phone number you control and hit your webhook locally with ngrok or deploy it to a test environment.

test_result = process_incoming_patient_text(
    from_number="+15551234567",
    message_text="Can I get help rescheduling my follow-up visit?"
)

print(test_result["status"])
print(test_result["twilio_sid"])
print(test_result["reply"])

Expected output:

sent
SMXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Thanks for reaching out. I can help with rescheduling your follow-up visit...

If you’re testing inbound SMS locally, verify that:

• •Twilio reaches your /sms webhook successfully
• •The webhook returns valid XML TwiML
• •The patient receives an SMS reply within a few seconds

Real-World Use Cases

• •

  Appointment triage bot

  • •Patients text symptoms or scheduling requests.
  • •LangChain classifies intent and drafts safe responses.
  • •Twilio sends confirmation or escalation instructions.
• •

  Post-visit follow-up automation

  • •After discharge or consultation, trigger reminder texts.
  • •Use LangChain to personalize instructions based on visit type.
  • •Use Twilio for delivery and retry handling.
• •

  Intake collection assistant

  • •Collect pre-appointment details over SMS.
  • •LangChain structures free-text responses into fields.
  • •Push those fields into your EHR or CRM pipeline after validation.

The key design choice is keeping language reasoning and transport separate. LangChain handles interpretation and generation; Twilio handles reliable messaging delivery. That split makes the system easier to test, easier to swap components later, and safer to operate in a regulated environment.

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.