Forem: Philip Balbas

How I Made a Bot to Plan My Trips Using Julep and Chainlit

Philip Balbas — Mon, 06 May 2024 14:53:42 +0000

As part of my generative AI series, this post will walk you through how I created an AI-powered travel agent using Julep and Chainlit. This bot can help you plan your next trip by suggesting destinations and activities and even generating an entire travel itinerary.

As a travel enthusiast, I've always wanted a personalized travel assistant that could help me discover new places and create custom itineraries. With the power of generative AI, I was able to bring this idea to life in just a few steps.

What You're Gonna Use/Tech Stack

To build this trip planning bot, I used:

Julep: An open-source framework for creating AI agents
Chainlit: A tool for easily adding chat interfaces to your AI projects

But, What's Julep?

Julep is an incredibly helpful framework that provides all the tools you need to create AI agents, manage user sessions, and store conversation memory. It allowed me to focus on designing my travel agent's capabilities without getting bogged down in the infrastructure.

Don't forget to ⭐ the Julep repo to show your support!

Step 1: Set Up Julep and Chainlit

First, install Julep and Chainlit in your Python environment:

pip install chainlit
pip install julep

Then, initialize the Julep client with your API key:

from julep import AsyncClient

api_key = "<YOUR_API_KEY>"

client = AsyncClient(api_key=api_key)

Step 2: Create the Travel Agent

Next, use the Julep API to create your AI travel agent. Give it a name, description, and a set of instructions that define its capabilities:

    agent = await client.agents.create(
        name="Travel Agent",
        about="You are a travel agent with several your of experience. You are knowledgeable about different travel destinations and can provide recommendations based on user preferences. You are also able to suggest flights, hotels, and other travel accommodations for users. You are friendly, helpful, and eager to assist users with their travel needs.",
        model="gpt-4-turbo",
        instructions=[
            "Ask the user where they would like to travel to.",
            'Ask the user what their budget is',
            'Ask the user what vibe they are looking for in a trip',
            'Ask the user what kind of activities they enjoy',
            "Depending on the user's responses, suggest travel destinations as a numbered list",
            "Suggest activities, nearby attractions, landmarks, and restaurants in the destination as a numbered list",
            "Ask if they are planning to visit multiple destinations",
            "Ask for how many days the user is planning to stay",
            "Prepare an itinerary for the user",
            "Give useful phrases in the local language",
    ])

Step 3: Set Up User & Session

Create a user and a session to facilitate the conversation between the user and the travel agent:

user = await client.users.create(name="Philip", about="Traveler")
session = await client.sessions.create(agent_id=agent.id, user_id=user.id, situation="You are greeting a user that's planning to go on a trip.")

Step 4: Set Up Chainlit Interface

Then, use Chainlit's decorators to define the chat interface:

@cl.on_chat_start
async def start():
    session_id = await setup_session()
    cl.user_session.set("session_id", session_id)

    response = await client.sessions.chat(session_id=session_id, messages=[{"content": "Greet the user", "role": "system"}], recall=True, remember=True, max_tokens=1000)
    await cl.Message(content=response.response[0][0].content).send()

@cl.on_message
async def main(message: cl.Message):
    session_id = cl.user_session.get("session_id")

    response = await client.sessions.chat(session_id=session_id, messages=[{"content": message.content, "role": "user"}], recall=True, remember=True, max_tokens=1000)
    await cl.Message(content=response.response[0][0].content).send()

Getting it to Plan

And that's it! Run your Chainlit app and start chatting with your new AI travel agent. It will ask about your preferences, suggest destinations and activities, and generate a personalized itinerary for your dream trip.

Use It to Plan Your Own Trip!

Want to try it out yourself? The full code for this project is available on my GitHub repo: https://github.com/philipbalbas/travel-agent

Feel free to clone it, customize the agent's capabilities, and start planning your next adventure!

And once again, don't forget to ⭐ Julep for making projects like this possible.

Happy travels! 🌎✈️

Effortlessly Create an AI Dungeon Master Bot Using Julep and Chainlit

Philip Balbas — Thu, 02 May 2024 03:26:18 +0000

Thanks to open-source tools, creating AI applications has become more accessible than ever. Similar to how cloud services such as AWS and Heroku have enabled nearly anyone to launch startups, platforms provided by companies like OpenAI and Meta are democratizing AI development. This shift allows almost anyone to build their own AI bots easily.

I've long been fascinated by the potential of generative AI and its applications. As an avid tabletop RPG (TTRPG) enthusiast, I'm particularly drawn to the narrative and story-driven aspects that shows like "Critical Role" portray. Inspired by this, I decided to create a simple, accessible tool to help introduce newcomers to the world of TTRPGs through engaging storytelling.

To bring this idea to life, I developed a choose-your-own-adventure-style text game. I utilized Julep's open-source tools along with the capabilities of GPT-4 Turbo to server as the backbone of the game.

In this project, I'll demonstrate how straightforward it is to generate story narratives and implement the user interface to showcase a practical application of generative AI in gaming.

Full disclosure: I previously worked at Julep AI and contributed to developing the tools I utilized to create this bot.

1. Install Julep and Chainlit

First, we will initiate a Python project and install Chainlit and Julep. You can find the API docs for Julep at https://github.com/julep-ai/julep



pip install chainlit
pip install julep

2. Get Julep API Key

We're using Julep primarily to leverage its features, namely agents, sessions and memory. First, let's get an API key to initiate the client. You can get an API key from https://platform.julep.ai.

3. Setup Julep Client

Next, initialize the client as follows. For the purposes of using Chainlit, we'll use async-await to prevent blocking the event loop or having it timing out.



from julep import AsyncClient

api_key = "<YOUR_API_KEY>"
base_url = "https://dev.julep.ai/api"

client = AsyncClient(api_key=api_key, base_url=base_url)

4. Create Agent and write prompts

Next, we'll generate the agent using gpt-4-turbo. This will serve as the bot for our game. Using the Julep API, we're giving it context on what the bot will be and what it should do. First, we're giving it a name and an about. Most importantly, we're giving it a set of instructions on how to run the games.

To code a choose-your-own-adventure game would naturally require thousands of lines of dialog and hundreds of if-statements to reach specific outcomes. The agent simplifies all of this and will generate dialog, backstories, storylines and outcomes for us.



agent = await client.agents.create(
    name="The GM",
    about="The GM is a veteran game master for several tabletop role-playing games such as Dungeons and Dragons 5th Edition, Call of Cthulhu 7th edition, Starfinder, Pathfinder 2nd Edition, Age of Sigmar Soulbound, Shadowrun, Cyberpunk, Vampire the Masquerade and many more. The GM has been running games for over 10 years and has a passion for creating immersive and engaging stories for their players. The GM is excited to bring their storytelling skills to the world of AI and help users create their own epic adventures.",
    model="gpt-4-turbo",
    instructions=[
        "You will first ask what system to play and what theme the user would like to play",
        "You will prepare a campaign complete with story, NPCs, quests and encounters",
        "Your story will start from level 1 and go up to level 5",
        "At the start of the game you will introduce the players to the world and the story",
        "Depending on the system, you will ask the user to create an appropriate character and provide a backstory",
        "You may suggest a pre-generated character for the user to play",
        'You will always ask the user what they would like to do next and provide numbered options for them to choose from.',
        'You will provide as much options as you can with a minimum of 8 options and include 1 - 2 really really unexpected and wild options',
        'You will do the dice rolls and provide the results of their actions to the user',
        "You will adjust the story based on the user's actions and choices",
        "Your story will end with a final boss fight and a conclusion to the story",
])

4. Create User and Session

Now, we're setting up the user and session. The user represents the individual interacting with the agent, while the session acts as a virtual space or channel facilitating the conversation between an agent and a user.

Additionally, we'll leverage the session's memory capability to retain the context from all prior interactions with a user. This will be very useful so we don't have to write our own database to store the context.



user = await client.users.create(name="Philip", about="TTRPG player")

    session = await client.sessions.create(agent_id=agent.id, user_id=user.id, situation="You are starting a new campaign. What system would you like to play and what theme would you like to explore?")

This is all it really takes to build the bot using Julep.

5. Setup Chainlit

Next, we'll build the chat interface. Chainlit makes this very easy.



import chainlit as cl


@cl.on_chat_start
async def start():
    session_id = await setup_session()

    cl.user_session.set("session_id", session_id)
    response = await client.sessions.chat(session_id=session_id, messages=[{"content": "Greet the user and ask what TTRPG system they would like to play or ask to continue from a previous campaign", "role": "system"}], recall=True, remember=True, max_tokens=1000)
    await cl.Message(
        content=response.response[0][0].content,
    ).send()

@cl.on_message
async def main(message: cl.Message):
    session_id = cl.user_session.get("session_id")

    response = await client.sessions.chat(session_id=session_id, messages=[{"content": message.content, "role": "user"}], recall=True, remember=True, max_tokens=1000)
    await cl.Message(
        content=response.response[0][0].content,
    ).send()

Finally run chainlit run app.py -w and open http://localhost:8000

With just a few lines of code and some prompting, we were able to make a simple text game. The responses might look different, but refining the instructions can make them more consistent for each game. You can view the entire code at https://github.com/philipbalbas/rpg-bot

Anyway, this might be one of a series of use cases, so keep an eye out. Don't forget to leave a ⭐ on the Julep repo to get more updates on the incredible features the Julep team is adding.