AI Receptionist for Apartment Rentals built with CrewAI

import os
from langchain_openai import ChatOpenAI


llm = ChatOpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
    model="gpt-4o"
)

from abc import ABC, abstractmethod
from pydantic import BaseModel
import string
import random
import hashlib


class SmartLock(ABC, BaseModel):
  guest_id: str
  apartment_id: str
  access_code_length: int = 4

  def _generate_access_code(self) -> str:
    hashable_string = self.guest_id + self.apartment_id
    guest_hash = hashlib.sha256(hashable_string.encode()).hexdigest()

    access_code = ""
    for i in guest_hash:
      if i.isdigit():
        access_code += i
        if len(access_code) == self.access_code_length:
          break

    if (len(access_code) != self.access_code_length):
      raise Exception("Access code not generated. Use the Escalate tool to notify the human-operator.")

    return access_code

  @abstractmethod
  def set_code(self, new_code: str):
    pass

class UpdateGuestWifiPassword(BaseModel, ABC):
  password_length: int = 14

  def __generate_random_password(self) -> str:
    characters = string.ascii_letters + string.digits
    password = ''.join(random.choice(characters) for i in range(self.password_length))
    return password


  @abstractmethod
  def _set_new_password(self, new_password: str) -> None:
    pass

  def update(self) -> str:
    new_password = self.__generate_random_password()
    self._set_new_password(new_password)
    return new_password

class NoOpSmartLock(SmartLock):
  def set_code(self, new_code: str):
    print(f"Setting code to {new_code}")

class NoOpWifiRouter(UpdateGuestWifiPassword):
  def _set_new_password(self, new_password: str) -> None:
    print(f"Setting new password to {new_password}")

from crewai_tools import BaseTool


class KeyBoxTool(BaseTool):
  name: str = "KeyBox"
  description: str = "Returns the access code to the box containing the apartment key. The access code is different for every guest but stays the same throughout their stay. The tool doesn't accept any arguments."
  smart_lock: SmartLock

  def _run(self) -> str:
    access_code = self.smart_lock._generate_access_code()
    self.smart_lock.set_code(access_code)
    return access_code


class Escalate(BaseTool):
  name: str = "Escalate"
  description: str = "Escalate the issue to the human operator. The tool accepts no arguments."

  def _run(self) -> str:
    # in the real implementation, I suggest you mark the conversation as escalated and stop sending new messages to AI until the human operator marks the issue as resolved
    # also, you will need to notify the operator somehow. I would use Opsgenie or PagerDuty for that because their notifications are super-annoying, and you cannot ignore them
    return "Escalated. Notify the user that a human operator will help them. Stop calling tools."


class WifiTool(BaseTool):
  name: str = "WifiRouter"
  description: str = "Return a new password for the Wifi. The tool doesn't accept any arguments. The tool should be used only once per conversation because it resets the password. If the user asks about the password again, reply with the same password as before."
  wifi_router: UpdateGuestWifiPassword

  def _run(self) -> str:
    return self.wifi_router.update()

from crewai import Agent


receptionist_agent = Agent(
    role="Receptionist",
    goal="Help the guests with their reservation",
    backstory="""You are a receptionist for a single-apartment short-term rental property. You help guests access the apartment, setup wifi, or escalate any questions they may have that you cannot handle.

 The key is in the black box on the right side of the door. When the user asks about it, retrieve the access code before replying.

 If the user's message doesn't require the usage of any tool, reply in a friendly way.
 If you escalate the issue, notify the user and call no other tools.""",
    llm=llm,
    max_iter=3,
    max_retry_limit=2,
    tools=[keyboxtool, wifitool, escalate],
    verbose=True
)

from crewai import Task


task = Task(
    description="""Reply to the user in the following conversation:

    {conversation_history}""",
    agent=receptionist_agent,
    tools=[keyboxtool, wifitool, escalate],
    expected_output="A single-sentence response to the user's message."
)

from crewai import Crew


crew = Crew(
    agents=[receptionist_agent],
    tasks=[task],
    verbose=True
)

def conversation_with_agent(user_input, conversation_history):
    conversation_history += f"\nUser: {user_input}\n"
    result = crew.kickoff(inputs={'conversation_history': conversation_history})

    agent_response = result.raw
    conversation_history += f"Agent: {agent_response}\n"
    print(agent_response)

    return conversation_history, agent_response

conversation_history = """"""

conversation_history, agent_response = conversation_with_agent("Hi", conversation_history)

conversation_history, agent_response = conversation_with_agent("How can I open the door?", conversation_history)

conversation_history, agent_response = conversation_with_agent("Where do I find the wifi password?", conversation_history)

conversation_history, agent_response = conversation_with_agent("Help! I locked myself in the restroom and cannot get out!", conversation_history)

conversation_history, agent_response = conversation_with_agent("What was the wifi password again?", conversation_history)