Orquestar tres agentes para una clínica dental con LangGraph, Qdrant, Mem0 y Temporal

  ┌──────────────────────────────────────────────────────────┐
  │                    LangGraph orchestrator                │
  │                                                          │
  │   ┌──────────────┐                                       │
  │   │ Router       │ ◄─── Canal (voz / WhatsApp / web)     │
  │   └──────┬───────┘                                       │
  │          │                                               │
  │  ┌───────┼──────────┬───────────────┐                    │
  │  ▼       ▼          ▼               ▼                    │
  │ Citas  Recordatorio Reseña       Fallback human         │
  │          ▲              ▲                               │
  │          │              │                               │
  │     ┌────┴─────┐   ┌────┴───────┐                        │
  │     │ Temporal │   │ Temporal   │                        │
  │     │ 24h/1h   │   │ 24h post   │                        │
  │     └──────────┘   └────────────┘                        │
  └──────────────────────────────────────────────────────────┘
         │                 │                  │
         ▼                 ▼                  ▼
      Calendario        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:
    # agente especializado con su propio prompt + tools de calendario
    result = booking_agent.run(state)
    return {**state, **result}

def reminder_handler(state: ClinicState) -> ClinicState:
    # atiende confirmaciones de recordatorios
    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": "Te paso con una recepcionista."}

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 = """
Eres el agente de reservas de Clínica Dental Numoru.
Tu única tarea es ayudar a agendar, reagendar o cancelar citas.

Reglas:
- Confirma nombre completo y teléfono antes de agendar.
- Respeta horario: lu-sa 9:00-19:00.
- Si el paciente pregunta precio o diagnóstico, usa search_clinic_info;
  si no está en el RAG, ofrece hablar con el doctor, nunca inventes.
- Si detectas urgencia médica real, transfiere inmediatamente con 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"),
)

# workflow Temporal
@workflow.defn
class AppointmentReminderWorkflow:
    @workflow.run
    async def run(self, appt: Appointment):
        # 24h antes
        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 antes
        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-cita
        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 después, pedir reseña pública
            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\nContexto previo del paciente:\n{bullets}\n"

define user ask medical_diagnosis
  "¿tengo caries?"
  "¿qué enfermedad tengo?"
  "¿es grave lo que tengo?"
  "¿necesito ortodoncia?"

define bot refuse medical_diagnosis
  "Para diagnosticar necesitamos verte. ¿Te agendo con el doctor?"

define user ask price
  "¿cuánto cuesta?"
  "¿qué precio tiene?"

define flow
  user ask medical_diagnosis
  bot refuse medical_diagnosis

define flow
  user ask price
  execute search_clinic_info
  # si no encuentra precio en RAG, el tool devuelve error y el flujo default responde "consulta con recepción"

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]