Orchestrating three agents for a dental clinic with LangGraph, Qdrant, Mem0, and Temporal

  ┌──────────────────────────────────────────────────────────┐
  │                    LangGraph orchestrator                │
  │                                                          │
  │   ┌──────────────┐                                       │
  │   │ Router       │ ◄─── Channel (voice / WhatsApp / web) │
  │   └──────┬───────┘                                       │
  │          │                                               │
  │  ┌───────┼──────────┬───────────────┐                    │
  │  ▼       ▼          ▼               ▼                    │
  │ Booking Reminder  Review         Human fallback         │
  │          ▲              ▲                               │
  │          │              │                               │
  │     ┌────┴─────┐   ┌────┴───────┐                        │
  │     │ Temporal │   │ Temporal   │                        │
  │     │ 24h/1h   │   │ 24h post   │                        │
  │     └──────────┘   └────────────┘                        │
  └──────────────────────────────────────────────────────────┘
         │                 │                  │
         ▼                 ▼                  ▼
      Calendar          WhatsApp           Google Reviews
      (MCP)             (MCP)              (MCP)
         │                 │                  │
         └─────────────────┴──────────────────┘
                           │
                           ▼
             Postgres + Qdrant + Redis + Mem0 + Langfuse

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver
from typing import TypedDict, Literal

class ClinicState(TypedDict):
    session_id: str
    patient_id: str | None
    channel: Literal["voice", "whatsapp", "web"]
    user_message: str
    intent: Literal["book", "reschedule", "cancel", "ask_info", "confirm", "review", "unknown"]
    working_memory: dict
    response: str
    tool_calls: list
    done: bool

def router_node(state: ClinicState) -> ClinicState:
    state["intent"] = classify_intent(state["user_message"])
    return state

def booking_node(state: ClinicState) -> ClinicState:
    # specialized agent with its own prompt + calendar tools
    result = booking_agent.run(state)
    return {**state, **result}

def reminder_handler(state: ClinicState) -> ClinicState:
    # handles reminder confirmations
    result = reminder_agent.run(state)
    return {**state, **result}

def review_handler(state: ClinicState) -> ClinicState:
    result = review_agent.run(state)
    return {**state, **result}

def human_fallback(state: ClinicState) -> ClinicState:
    trigger_human_handoff(state)
    return {**state, "done": True, "response": "I'll connect you with a receptionist."}

def route(state: ClinicState) -> str:
    intent = state["intent"]
    if intent in ("book", "reschedule", "cancel", "ask_info"):
        return "booking"
    if intent == "confirm":
        return "reminder"
    if intent == "review":
        return "review"
    return "fallback"

graph = StateGraph(ClinicState)
graph.add_node("router", router_node)
graph.add_node("booking", booking_node)
graph.add_node("reminder", reminder_handler)
graph.add_node("review", review_handler)
graph.add_node("fallback", human_fallback)

graph.set_entry_point("router")
graph.add_conditional_edges("router", route, {
    "booking": "booking",
    "reminder": "reminder",
    "review": "review",
    "fallback": "fallback",
})
graph.add_edge("booking", END)
graph.add_edge("reminder", END)
graph.add_edge("review", END)
graph.add_edge("fallback", END)

checkpointer = PostgresSaver.from_conn_string(os.getenv("POSTGRES_URL"))
app = graph.compile(checkpointer=checkpointer)

BOOKING_SYSTEM = """
You are the booking agent for Numoru Dental Clinic.
Your single task is helping book, reschedule or cancel appointments.

Rules:
- Confirm full name and phone before booking.
- Honor hours: Mon-Sat 9:00-19:00.
- If the patient asks for price or diagnosis, use search_clinic_info;
  if it's not in the RAG, offer the doctor — never make it up.
- If you detect a real medical urgency, transfer immediately with transfer_to_emergency.
"""

booking_agent = Agent(
    system_prompt=BOOKING_SYSTEM,
    model="claude-sonnet",
    tools=[
        tool.find_available_slot,
        tool.book_appointment,
        tool.reschedule,
        tool.cancel,
        tool.search_clinic_info,
        tool.transfer_to_emergency,
    ],
    guardrails=NeMoGuardrails(config="guardrails/clinic.colang"),
)

# Temporal workflow
@workflow.defn
class AppointmentReminderWorkflow:
    @workflow.run
    async def run(self, appt: Appointment):
        # 24h before
        await workflow.sleep(appt.start - timedelta(hours=24))
        await workflow.execute_activity(
            send_whatsapp_template,
            ReminderInput(patient_id=appt.patient_id, slot=appt.start, kind="24h"),
            start_to_close_timeout=timedelta(minutes=2),
        )
        # 1h before
        await workflow.sleep(appt.start - timedelta(hours=1))
        await workflow.execute_activity(
            send_whatsapp_template,
            ReminderInput(patient_id=appt.patient_id, slot=appt.start, kind="1h"),
            start_to_close_timeout=timedelta(minutes=2),
        )

@workflow.defn
class PostVisitReviewWorkflow:
    @workflow.run
    async def run(self, appt: Appointment):
        # 4h post-visit
        await workflow.sleep(appt.end + timedelta(hours=4))
        satisfied = await workflow.execute_activity(
            nps_one_question,
            NpsInput(patient_id=appt.patient_id),
            start_to_close_timeout=timedelta(minutes=10),
        )
        if satisfied >= 8:
            # 24h later, ask for a public review
            await workflow.sleep(timedelta(hours=20))
            await workflow.execute_activity(
                request_review,
                ReviewInput(patient_id=appt.patient_id, channel="google"),
            )

from mem0 import Memory

memory = Memory.from_config({
    "vector_store": {
        "provider": "qdrant",
        "config": {"host": "qdrant", "port": 6333, "collection_name": "clinic_patients"},
    },
    "llm": {"provider": "litellm", "config": {"model": "claude-sonnet"}},
})

def enrich_prompt_with_memory(patient_id: str, query: str) -> str:
    facts = memory.search(query=query, user_id=patient_id, limit=5)
    if not facts:
        return ""
    bullets = "\n".join(f"- {f['memory']}" for f in facts)
    return f"\n\nPatient prior context:\n{bullets}\n"

define user ask medical_diagnosis
  "do I have a cavity?"
  "what disease do I have?"
  "is it serious?"
  "do I need braces?"

define bot refuse medical_diagnosis
  "We need to see you to diagnose. Shall I book you with the doctor?"

define user ask price
  "how much does it cost?"
  "what's the price?"

define flow
  user ask medical_diagnosis
  bot refuse medical_diagnosis

define flow
  user ask price
  execute search_clinic_info
  # if no price found in RAG, the tool returns an error and the default flow says "ask reception"

services:
  clinic-orchestrator:
    image: numoru/clinic-orchestrator:latest
    environment:
      POSTGRES_URL: postgres://lf:${LF_DB_PASSWORD}@langfuse-db:5432/clinic
      QDRANT_URL: http://qdrant:6333
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379/3
      LITELLM_URL: http://litellm:4000
      LANGFUSE_PUBLIC_KEY: ${LF_PUBLIC_KEY}
      TEMPORAL_HOST: temporal:7233
    depends_on: [langfuse-db, qdrant, redis, litellm, temporal]

  temporal:
    image: temporalio/auto-setup:1.25
    environment:
      DB: postgres12
      DB_PORT: 5432
      POSTGRES_USER: lf
      POSTGRES_PWD: ${LF_DB_PASSWORD}
      POSTGRES_SEEDS: langfuse-db
    networks: [core]

  clinic-temporal-worker:
    image: numoru/clinic-temporal-worker:latest
    environment:
      TEMPORAL_HOST: temporal:7233
      LITELLM_URL: http://litellm:4000
    depends_on: [temporal]