DEV Community: Julep

Create Your Own AI Discord Bot with Julep

Ayush Thakur — Sun, 04 Aug 2024 13:30:35 +0000

Having a Discord bot for your server that interacts with users and resolves their queries on your behalf is incredibly useful. However, building such a bot can be extremely challenging and may take months due to the complexities involved in data preprocessing, model training, hyperparameter training, and deployment. This is where Julep comes in to save the day.

Julep is a platform that helps to build stateful and functional LLM-powered applications. Using Julep, you can create a fully operational AI application with minimal code.

While platforms such as OpenAI's GPT-3, Microsoft's Azure Bot Service, and Google's Dialogflow enable the development of AI applications, Julep distinguishes itself with unique benefits. Julep offers unique features like composio tools integration, adaptive context, multiple AI Agents support, and in-built RAG.

In this blog, we will create an AI Discord Bot using Julep and add it to a live Discord Server to try it. We will walk through each step and understand how you can use Julep in your projects.

Prerequisites

Make sure you have Node.js installed on your device. Download and install Node.js from their official website.

If you like the posts on the Julep blog so far, please consider please consider giving Julep a star on GitHub, it helps us to reach and help more developers.

julep-ai / julep

A new DSL and server for AI agents and multi-step tasks

^{English | 中文翻译 | 日本語翻訳 | French}

Explore Docs · Discord · 𝕏 · LinkedIn

Note

👨‍💻 Here for the devfest.ai event ? Join our Discord and check out the details below.

Get your API key here.

🌟 Contributors and DevFest.AI Participants (Click to expand)

🌟 Call for Contributors!

We're excited to welcome new contributors to the Julep project! We've created several "good first issues" to help you get started. Here's how you can contribute:

Check out our CONTRIBUTING.md file for guidelines on how to contribute.
Browse our good first issues to find a task that interests you.
If you have any questions or need help, don't hesitate to reach out on our Discord channel.

Your contributions, big or small, are valuable to us. Let's build something amazing together! 🚀

🎉 DevFest.AI October 2024

Exciting news! We're participating in DevFest.AI throughout October 2024! 🗓️

Contribute to Julep during this…

View on GitHub

Building Discord Bot

Create a project directory and open it in VS code. Run this command in the terminal:

npm init -y

This will initialize a Nodejs project and create a package.json file with some default settings.

We will require some libraries to build our AI Discord bot. These libraries are:

dotenv - To retrieve the value stored in the .env file
julep SDK - To interact with a specific service or API provided by Julep
discord.js - To easily interact with the Discord API

To install these libraries, run this command:

npm i dotenv @julep/sdk discord.js

Get Julep API Key

To use Julep in our project, we need an API Key.

Go to platform.julep.ai and Sign in with Google account credentials. Copy the YOUR API TOKEN present on the top-right corner.

This API Token will serve as your API key.

Create a .env file in your project directory and paste the following code:

JULEP_API_KEY = apiKey

Replace the apikey with the copied API Token.

Get Discord Bot Token

To get the Discord Bot token, go to Discord Developer Portal and login with your credentials.

Click on New Application and give a name to your application.

Navigate to the Bot section on left-hand side and click on Reset Token and it will generate a token, copy it.

Open the .env file and paste the following code:

BOT_KEY = “botToken”

Replace the botToken with the token you copied earlier.

Create the Bot

Now that we have the required API key and Bot Key, let’s start creating the bot.

Create a file in your project directory and name it index.js. Then, import the installed libraries into the file:

require("dotenv").config();
const { Client, GatewayIntentBits, Collection } = require("discord.js");
const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});
const julep = require("@julep/sdk");

Create a new Julep Client using julep.Client() method. This client interfaces with the Julep API and sets up the managers for agents, users, sessions, documents, memories, and tools.

const apiKey = process.env.JULEP_API_KEY;
const julepClient = new julep.Client({ apiKey });

Add a log to display a message when the Discord client is ready. This will confirm that the Discord client has been successfully created.

client.once("ready", () => {
    console.log(`Logged in as ${client.user.tag}!`);
  });

Now, we want to capture the message content each time the user enters a new message. For that, we will use the messageCreate action.

client.on("messageCreate", async (message) => {

When a user sends a message in the channel, a message object is created. This message object contains every detail about the sent message. We will use this message object to capture some of those details.

Next step is to make sure that the user is not a bot and a human. For that we will check if bot property is present in message object or not:

if (message.author.bot) {
    return;
  }

We want to show the Bot is typing…. animation to let the users know that the bot is replying to their query. For this we will use the sendTyping() function.

await message.channel.sendTyping();

Now, let’s create users, agents, and sessions to perform the interaction with Julep API.

Creating User

A User object represents an entity, either a person or a system, that interacts with the application. Every AI application built with Julep supports multiple users, each able to interact with the Agent. Each user is unique, with their own identity and role.

It is not a necessary thing to define a User. Applications can function properly even in the absence of a User. However, it's a good idea to create a user profile for each person or system interacting with the Agent for better organization and tracking. Adding basic details about the user helps the application understand their behavior, allowing it to provide personalized results that match the user's preferences and needs.

Julep comes with a users.create() method which we can be used on the client to create a user. Creating a user demands 4 attributes:

Name - Name of the user
About - Small description of the user
Documents - Essential documents formatted as text tailored to the user's needs (Optional)
Metadata - Additional data beyond the ID that pertains to the user within the application (Optional)

Here’s an example:

const user = await client.users.create({
    name: "Sam",
    about: "Machine Learning Developer and AI Enthusiast",
    docs:[{"title": "AI Efficiency Report", "content": "...", "metadata": {"page": 1}}],  // Optional
    metadata:{"db_uuid": "1234"}, // Optional
  });

Now, let’s create a user for our Discord bot. We will keep the name of the user dynamic to capture the name of each user interacting with the Discord bot.

const user = await julepClient.users.create({
    name: message.author.globalName,
    about: "A test user",
  });

Here, we have created a user with the name assigned to globalName property and A test user as description.

Creating Agent

An Agent is a smart interface that connects the user and the application, managing interactions to improve the user experience. Agents are designed to handle user queries and provide customized results or suggestions.

Agents store all the settings and configurations for the LLM models you want to use in your AI application. This allows the application to perform specific tasks and meet individual user preferences.

Agents can be simple, like a chatbot, or more complex, like advanced AI assistants that understand natural language and perform complex tasks.

In Julep, you can create an agent using the agents.create() method. Creating an agent requires a set of attributes:

Name - Name of the agent
About - Small description of the agent (Optional)
Instructions - List of instructions for the agent to follow (Optional)
Tools - List of functions for agent to execute tasks (Optional)
Model Name - LLM Model that agent will use (Optional)
Settings - Configurations on LLM model (Optional)
Documents - Important documents in text format to be used by agent to improve the persona (Optional)
Metadata - Additional information apart from ID to identify the user or agent (Optional)

Here’s an example:

const agent = client.agents.create(
    (name = "Cody"),
    (about =
      "Cody is an AI powered code reviewer. It can review code, provide feedback, suggest improvements, and answer questions about code."),
    (instructions = [
      "On every new issue, Review the issue made in the code. Summarize the issue made in the code and add a comment",
      "Scrutinize the changes very deeply for potential bugs, errors, security vulnerabilities. Assume the worst case scenario and explain your reasoning for the same.",
    ]),
    (tools = [
      {
        type: "function",
        function: {
          name: "github_comment",
          description:
            "Posts a comment made on a GitHub Pull Request after every new commit. The tool will return a boolean value to indicate if the comment was successfully posted or not.",
          parameters: {
            type: "object",
            properties: {
              comment: {
                type: "string",
                description:
                  "The comment to be posted on the issue. It should be a summary of the changes made in the PR and the feedback on the same.",
              },
              pr_number: {
                type: "number",
                description:
                  "The issue number on which the comment is to be posted.",
              },
            },
            required: ["comment", "pr_number"],
          },
        },
      },
    ]),
    (model = "gpt-4"),
    (default_settings = {
      temperature: 0.7,
      top_p: 1,
      min_p: 0.01,
      presence_penalty: 0,
      frequency_penalty: 0,
      length_penalty: 1.0,
    }),
    (docs = [{ title: "API Reference", content: "...", metadata: { page: 1 } }]),
    (metadata = { db_uuid: "1234" })
  );

Now, let’s create the agent for our Discord bot:

const agent = await julepClient.agents.create({
  name: "Jarvis an AI Assistant",
  model: "gpt-4-turbo",
});

Here, we've used the gpt-4-turbo LLM model in this agent, but Julep supports various LLM models for creating AI applications. Check out the documentation for more information.

Creating Session

A Session is a period where users interact with the agent. It includes all the back-and-forth messaging and relevant details.

Sessions store all messages exchanged between the user and agent. This helps the AI understand the conversation better and provide more personalized answers.

To create a session, use the sessions.create() method. Here are the attributes it requires:

Agent ID - ID of the created agent
User ID - ID of the created user (Optional)
Situation - A prompt to describe the background of the interaction
Metadata - Additional information apart from IDs to identify the session (Optional)

Situation attribute is important in the session because it provides context for the interaction. This helps the agent understand the user's query better and give more personalized responses.

Here’s an example:

// Assuming 'client' is an object with a 'sessions' property containing a 'create' method
let session = client.sessions.create({
    agent_id: agent.id,
    user_id: user.id,
    situation: `
          You are James a Software Developer, public speaker & renowned educator.
          You are an educator who is qualified to train students, developers & entrepreneurs.
          About you:
          ...
          Important guidelines:
          ...
      `,
    metadata: { db_uuid: "1234" },
  });

Let’s create a session for our Discord bot:

const situationPrompt =
"Your name is Jarvis and you are a Senior Software Engineer that has decades of experience in coding. You have worked with almost every programming language present there like C, C++, C#, JavaScript, TypeScript, Python, Swift, Ruby, Go, Rust, Blockchain, Solidity, etc. People comes to you and ask their questions related to coding. Users ask their doubts, queries, project ideas, questions, solutions and everything about related to coding. You help users with their coding related problems. But you are savage and sarcastic in nature. Therefore, you answer each question in a very sarcastic and savage manner. Sometimes you also roast users based upon the query they have asked. But no matter how sarcastic and savage you are, you do provide the answer user is looking for.";


const session = await julepClient.sessions.create({
agentId: agent.id,
userId: user.id,
situation: situationPrompt,
});

Here, we have created the situationPrompt that has the whole situation/context for our Discord bot to perform the interaction. Then used this situationPrompt for situation attribute and specified other mandatory attributes to create a session.

Getting Message Response

After creating the user, agent, and session, we need to manage the interaction. We'll use the sessions.chat() method to handle the chat and get the response message.

This method requires two attributes to work: session.id and an object containing a messages array.

const chatParams = {
    messages: [
      {
        role: "user",
        name: message.author.globalName,
        content: message.content,
      },
    ],
    max_tokens: 1000,
  };
  const chatResponse = await julepClient.sessions.chat(session.id, chatParams);
  const responseMessage = chatResponse.response[0][0].content;
  const chunks = responseMessage.match(/[\s\S]{1,2000}/g);

  // Send each chunk as a separate message
  for (const chunk of chunks) {
    await message.channel.send(chunk);
  }

Here, we have created the chatParams object that has a messages array. This array includes:

role - role of the message sender, “user”
name - name of the message sender, message.author.globalName
content - content of the message, message.content

Along with this, the chatParams also holds a max_tokens property with the value 1000, which represents the maximum number of tokens to generate in the chat completion.

Following that, the sessions.chat() method is called on the client with session.id and chatParams as arguments. The resultant object is stored in chatResponse.

The value of the content property is extracted from chatResponse and stored in responseMessage.

Then, the message stored in responseMessage is split into smaller groups of 2000 characters and stored in the chunks variable.

After this, a for-of loop is used on the chunks array to send each chunk as a message to the user using the channel.send() method.

Lastly, the client.login(token) is used to authenticate and connect a client (like a Discord bot) to a server using a specified token.

Here’s the full index.js code:

require("dotenv").config();
const { Client, GatewayIntentBits, Collection } = require("discord.js");
const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});
const julep = require("@julep/sdk");

const apiKey = process.env.JULEP_API_KEY;
const julepClient = new julep.Client({ apiKey });

client.commands = new Collection();

const token = process.env.BOT_KEY;

client.once("ready", () => {
  console.log(`Logged in as ${client.user.tag}!`);
});

client.on("messageCreate", async (message) => {
  if (message.author.bot) {
    return;
  }
  await message.channel.sendTyping();
  const user = await julepClient.users.create({
    name: message.author.globalName,
    about: "A test user",
  });

  const agent = await julepClient.agents.create({
    name: "July an AI Assistant",
    model: "gpt-4-turbo",
  });

  const situationPrompt =
    "Your name is Jarvis and you are a Senior Software Engineer that has decades of experience in coding. You have worked with almost every programming language present there like C, C++, C#, JavaScript, TypeScript, Python, Swift, Ruby, Go, Rust, Blockchain, Solidity, etc. People comes to you and ask their questions related to coding. Users ask their doubts, queries, project ideas, questions, solutions and everything about related to coding. You help users with their coding related problems. But you are savage and sarcastic in nature. Therefore, you answer each question in a very sarcastic and savage manner. Sometimes you also roast users based upon the query they have asked. But no matter how sarcastic and savage you are, you do provide the answer user is looking for.";
  const session = await julepClient.sessions.create({
    agentId: agent.id,
    userId: user.id,
    situation: situationPrompt,
  });

  const chatParams = {
    messages: [
      {
        role: "user",
        name: message.author.globalName,
        content: message.content,
      },
    ],
    max_tokens: 1000,
  };
  const chatResponse = await julepClient.sessions.chat(session.id, chatParams);
  const responseMessage = chatResponse.response[0][0].content;
  const chunks = responseMessage.match(/[\s\S]{1,2000}/g);

  // Send each chunk as a separate message
  for (const chunk of chunks) {
    await message.channel.send(chunk);
  }
});

client.login(token);

Congratulations your Discord Bot is successfully created.

Deploy the bot

The bot is completed, we will run it and try it.

To deploy the bot, run the command in the terminal:

node index.js

If your bot starts running successfully, you should see this message in log window:

Logged in as botName#botTag

with your Bot name and Bot tag in-place of botName and botTag.

Now, to try out the Discord bot, we need to add it in a Discord server.

Adding Bot to a Server

Go to the Discord Developer Portal and open your created Discord bot.

Navigate to the OAuth2 section on the left-hand side. Scroll down to the OAuth2 URL Generator and check the bot box.

Further down, under Bot Permissions, select the necessary permissions for your Discord bot, such as Send Messages, Read Message History, and Manage Messages.

A URL will be generated in the Generated URL section. Copy this URL and paste it into your web browser.

Select the desired server from the dropdown menu and click Authorize.

Your bot will now be added to the server.

Now you can try out your Discord bot, message him, and get his responses.

Here’s a live demo of the Discord bot:

Your Discord Bot is running successfully.

Project link - https://github.com/ayush2390/Jarvis-bot

Try out Jess, an AI Discord bot made using Julep, Click Here

Excited to see what more Julep offers? The journey starts with a single click. Visit the repository and give it a star:

julep-ai / julep

A new DSL and server for AI agents and multi-step tasks

^{English | 中文翻译 | 日本語翻訳 | French}

Explore Docs · Discord · 𝕏 · LinkedIn

Note

👨‍💻 Here for the devfest.ai event ? Join our Discord and check out the details below.

Get your API key here.

🌟 Contributors and DevFest.AI Participants (Click to expand)

🌟 Call for Contributors!

We're excited to welcome new contributors to the Julep project! We've created several "good first issues" to help you get started. Here's how you can contribute:

Check out our CONTRIBUTING.md file for guidelines on how to contribute.
Browse our good first issues to find a task that interests you.
If you have any questions or need help, don't hesitate to reach out on our Discord channel.

Your contributions, big or small, are valuable to us. Let's build something amazing together! 🚀

🎉 DevFest.AI October 2024

Exciting news! We're participating in DevFest.AI throughout October 2024! 🗓️

Contribute to Julep during this…

View on GitHub

Check out the tutorial for a deeper understanding of Julep.

Have any questions or feedback? Join the Julep Discord Community

discord.com

Build your First AI Agent with Julep: A Step-by-Step Guide

Ayush Thakur — Tue, 18 Jun 2024 16:47:52 +0000

Creating an AI app from scratch can be a very challenging task. Whether you want to build a simple chatbot or an advanced intelligent virtual assistant, it can take weeks to develop the desired app successfully. But that’s where Julep comes to rescue us.

Julep is a platform that helps to build stateful and functional LLM-powered applications. With Julep, you can build a fully functional AI app with just a few lines of code.

Platforms like OpenAI's GPT-3, Microsoft's Azure Bot Service, and Google's Dialogflow can build AI applications. However, Julep stands out due to its advantages like statefulness to track conversation history and context, easy integration with multiple LLMs, and a user-friendly interface for managing users, agents, and sessions.

In this blog, we will create Movio, an AI-powered Movie Companion App that provides recommendations and information about any movie the user asks for. We will walk through each step and understand how you can use Julep in your projects.

Let’s get started!

Prerequisites

Make sure you have Nodejs installed in your device. Download and Install Node.js from their official website

If you like the posts on the Julep blog so far, please consider giving Julep a star on GitHub, it helps us to reach and help more developers.

julep-ai / julep

A new DSL and server for AI agents and multi-step tasks

^{English | 中文翻译 | 日本語翻訳 | French}

Explore Docs · Discord · 𝕏 · LinkedIn

Note

👨‍💻 Here for the devfest.ai event ? Join our Discord and check out the details below.

Get your API key here.

🌟 Contributors and DevFest.AI Participants (Click to expand)

🌟 Call for Contributors!

We're excited to welcome new contributors to the Julep project! We've created several "good first issues" to help you get started. Here's how you can contribute:

Check out our CONTRIBUTING.md file for guidelines on how to contribute.
Browse our good first issues to find a task that interests you.
If you have any questions or need help, don't hesitate to reach out on our Discord channel.

Your contributions, big or small, are valuable to us. Let's build something amazing together! 🚀

🎉 DevFest.AI October 2024

Exciting news! We're participating in DevFest.AI throughout October 2024! 🗓️

Contribute to Julep during this…

View on GitHub

Creating React App

To create a React App, run this command in the terminal:

npm create-vite@latest

You can check out the Vite Docs to create a React app.

Create the basic structure in the App.jsx file. Add an <input> tag allowing the users to enter the query:

<div className="container">
      <h1>Hi, I'm Movio</h1>
      <h4>Your Ultimate Movie Companion</h4>
      <div id="conversation">
        {conversation.map((item, index) => (
          <p key={index} className={item.role}>
            {item.message}
          </p>
        ))}
      </div>
      <input
        type="text"
        id="queryInput"
        placeholder="Ask me anything about Movies..."
        value={query}
        onChange={(e) => setQuery(e.target.value)}
      />
      <button onClick={sendQuery}>Submit</button>
    </div>

To handle and capture the user’s query, we have defined a functionality:

const [query, setQuery] = useState("");
const [conversation, setConversation] = useState([]);

We have used useState() hook to define query and conversation variables along with their state updating functions.

const sendQuery = async () => {
    if (!query) return;


    // Append user message to conversation
    setConversation((prev) => [...prev, { role: "user", message: query }]);
    setQuery("");


    try {
      const response = await axios.post("http://localhost:3000/chat", {
        query,
      });


      const agentResponse = response.data.response;


      // Append agent response to conversation
      setConversation((prev) => [
        ...prev,
        { role: "agent", message: agentResponse },
      ]);
    } catch (error) {
      console.error("Error fetching response:", error);
    }
  };

The function sendQuery() first checks if the query is empty. If it isn't, it updates the conversation state by appending a new object with role as "user" and message as the query. Then, it resets the query to an empty string using setQuery("").

Inside the try block, axios posts the user's query to the endpoint. The server's response is stored in agentResponse, which is extracted from the response data.

Next, setConversation is used again to add the agent's response to the conversation state, with role as "agent" and message as agentResponse.
Finally, any errors during the axios request are caught in the catch block and logged to the console.

Here’s the full App.jsx code:

import React, { useState } from "react";
import axios from "axios";

function App() {
  const [query, setQuery] = useState("");
  const [conversation, setConversation] = useState([]);

  const sendQuery = async () => {
    if (!query) return;

    // Append user message to conversation
    setConversation((prev) => [...prev, { role: "user", message: query }]);
    setQuery("");

    try {
      const response = await axios.post("http://localhost:3000/chat", {
        query,
      });

      const agentResponse = response.data.response;

      // Append agent response to conversation
      setConversation((prev) => [
        ...prev,
        { role: "agent", message: agentResponse },
      ]);
    } catch (error) {
      console.error("Error fetching response:", error);
    }
  };

  return (
    <div className="container">
      <h1>Hi, I'm Movio</h1>
      <h4>Your Ultimate Movie Companion</h4>
      <div id="conversation">
        {conversation.map((item, index) => (
          <p key={index} className={item.role}>
            {item.message}
          </p>
        ))}
      </div>
      <input
        type="text"
        id="queryInput"
        placeholder="Ask me anything about Movies..."
        value={query}
        onChange={(e) => setQuery(e.target.value)}
      />
      <button onClick={sendQuery}>Submit</button>
    </div>
  );
}

export default App;

Let's start integrating Julep in our project.

Installing Libraries

For the Movie Companion app, we will install some necessary libraries. These libraries are:

express - To create and manage your web server
julep SDK - To interact with a specific service or API provided by Julep
body-parser - To parse incoming request bodies, making it easier to handle data sent by clients
cors - To enable cross-origin requests, allowing your server to handle requests from different domains
dotenv - To retrieve the value stored in the .env file
axios - a promise-based HTTP Client for node.js and the browser

Run this command to install libraries:

npm install express @julep/sdk cors body-parser dotenv axios

Integrating Julep

To integrate Julep, we need an API key.

Go to platform.julep.ai and Sign in with Google account credentials. Copy the YOUR API TOKEN present on the top-right corner.

This API Token will serve as your API key.

Create a .env file in your project directory and paste the following code:

JULEP_API_KEY = “api_key”

Replace the api_key with the copied API Token.

Create a file in src directory and name it server.js. Whole Julep code will come in this file.

Firstly, we will import the required libraries.

import express from "express";
import julep from "@julep/sdk";
import bodyParser from "body-parser";
import cors from "cors";
import { fileURLToPath } from "url"; // Import the fileURLToPath function
import path from "path";
import dotenv from "dotenv";

Create a new client using Julep SDK‘s Client class. This client interacts with the Julep API and initializes the managers for agents, users, sessions, documents, memories, and tools.

const apiKey = process.env.JULEP_API_KEY;
const client = new julep.Client({ apiKey });

Now, we will create an Express app instance to serve as the backend server. Use the bodyparser.json() to configure the app to parse incoming JSON requests automatically, and cors() to enable Cross-Origin Resource Sharing (CORS) allowing requests from multiple origins.

const app = express();
app.use(bodyParser.json());
app.use(cors());

Set up an asynchronous route handler for POST requests to the Express app's /chat endpoint.

app.post("/chat", async (req, res) => {

Inside the try block, Create a query variable that stores the query entered by the user.

try {
const query = req.body.query;

Now, let’s create users, agents, and sessions to perform the interaction with Julep API.

Creating User

User object represents an entity, either a real person or a system, that interacts with the application. Every AI application developed using Julep supports multiple users, each capable of interacting with the Agent. Each of these users is distinct, meaning they have their own unique identities and assigned roles.

User is an optional entity, and an application can function properly without defining one. However, it's advisable to create a user profile for each individual or system interacting with the Agent for better organization and tracking. Specifically, adding some basic details about the user can help the application better understand their behavior. This enables the application to provide personalized results tailored to the user's preferences and needs.

When it comes to creating a user, Julep offers a users.create() method which we can be used on the client to create a user. Creating a user demands 4 attributes:

Name - Name of the user
About - Small description of the user
Documents - Essential documents formatted as text tailored to the user's needs (Optional)
Metadata - Additional data beyond the ID that pertains to the user within the application (Optional)

Here’s an example:

    const user = await client.users.create({
      name: "Sam",
      about: "Machine Learning Developer and AI Enthusiast",
      docs:[{"title": "AI Efficiency Report", "content": "...", "metadata": {"page": 1}}],  // Optional
      metadata:{"db_uuid": "1234"}, // Optional
    });

Now, let’s create a user for our Movie Companion app:

const user = await client.users.create({
      name: "Ayush",
      about: "A developer",
    });

Here, we have created a user with name Ayush and A developer as description.

Creating Agents

Agent is the intelligent interface serving between the user and the application, handling all the interactions and enhancing the user experience. Agents are programmed to process the queries user has asked for and provide tailored results or suggestions.

Agent contains all the configurations and settings of LLM Models you want to use in your AI application. This enables the applications to carry out specific tasks and cater to the individual preferences of users.

These agents can be as simple as a chatbot and can range up to highly complex AI-driven intelligent assistants capable of understanding natural language and performing intricate tasks.

Similarly, like users, Julep includes the agents.create() method to create an agent. Creating an agent requires a collection of attributes:

Name - Name of the agent
About - Small description of the agent (Optional)
Instructions - List of instructions for the agent to follow (Optional)
Tools - List of functions for agent to execute tasks (Optional)
Model Name - LLM Model that agent will use (Optional)
Settings - Configurations on LLM model (Optional)
Documents - Important documents in text format to be used by agent to improve the persona (Optional)
Metadata - Additional information apart from ID to identify the user or agent (Optional)

Here’s an example:

const agent = client.agents.create(
  (name = "Cody"),
  (about =
    "Cody is an AI powered code reviewer. It can review code, provide feedback, suggest improvements, and answer questions about code."),
  (instructions = [
    "On every new issue, Review the issue made in the code. Summarize the issue made in the code and add a comment",
    "Scrutinize the changes very deeply for potential bugs, errors, security vulnerabilities. Assume the worst case scenario and explain your reasoning for the same.",
  ]),
  (tools = [
    {
      type: "function",
      function: {
        name: "github_comment",
        description:
          "Posts a comment made on a GitHub Pull Request after every new commit. The tool will return a boolean value to indicate if the comment was successfully posted or not.",
        parameters: {
          type: "object",
          properties: {
            comment: {
              type: "string",
              description:
                "The comment to be posted on the issue. It should be a summary of the changes made in the PR and the feedback on the same.",
            },
            pr_number: {
              type: "number",
              description:
                "The issue number on which the comment is to be posted.",
            },
          },
          required: ["comment", "pr_number"],
        },
      },
    },
  ]),
  (model = "gpt-4"),
  (default_settings = {
    temperature: 0.7,
    top_p: 1,
    min_p: 0.01,
    presence_penalty: 0,
    frequency_penalty: 0,
    length_penalty: 1.0,
  }),
  (docs = [{ title: "API Reference", content: "...", metadata: { page: 1 } }]),
  (metadata = { db_uuid: "1234" })
);

Now, let’s create the agent for our Movio app:

    const agent = await client.agents.create({
      name: "Movie suggesting assistant",
      model: "gpt-4-turbo",
    });

As you can see, we have used the gpt-4-turbo LLM model in this agent, but Julep supports multiple LLM models that you can use to create AI applications. Check out the documentation to know more.

Creating Sessions

Session is an entity where the users interact with the agent. It’s the period of interaction between the user and the agent. It serves as a framework for the entire interaction that happens, including back-and-forth messaging queries and any other relevant details.

Sessions store a record of all the messages exchanged between the user and agent. This record helps the AI understand the ongoing conversation better and provide more personalized answers.

To create a session, we can use the sessions.create() method. Let’s take a look at the attributes it requires:

Agent ID - ID of the created agent
User ID - ID of the created user (Optional)
Situation - A prompt to describe the background of the interaction
Metadata - Additional information apart from IDs to identify the session (attribute)

Situation attribute plays a vital role in the session as it provides a context for the interaction or the conversation. The situation helps the agent better understand and compute the user’s query and give more tailored replies.

Here’s an example:

// Assuming 'client' is an object with a 'sessions' property containing a 'create' method
let session = client.sessions.create({
  agent_id: agent.id,
  user_id: user.id,
  situation: `
        You are James a Software Developer, public speaker & renowned educator.
        You are an educator who is qualified to train students, developers & entrepreneurs.
        About you:
        ...
        Important guidelines:
        ...
    `,
  metadata: { db_uuid: "1234" },
});

Let’s create a session for our Movio app:

    const session = await client.sessions.create({
      agentId: agent.id,
      userId: user.id,
      situation:
        "You are Movio. You tell the people about movies they ask for, and recommend movies to the users",
    });

Here, the agentID and userId are the IDs of the agent and user we created earlier, and the situation is the small context provided for the interaction.

Getting Response Message

After creating the user, agent, and session, we need to handle the interaction. We will use the sessions.chat() method to handle the chat interaction and get the response message.

This method demands two attributes to function - session.id and an object having messages array.

    const chatParams = {
      messages: [
        {
          role: "user",
          name: "Ayush",
          content: query,
        },
      ],
    };
    const chatResponse = await client.sessions.chat(session.id, chatParams);
    const responseMessage = chatResponse.response[0][0].content;


    res.json({ response: responseMessage });

Here, chatParams object contains the messages array, which includes an object with three properties:

role: The role of the message sender, "user".
name: The user's name, "Ayush".
content: The user's query, stored in the variable query.

Then, the sessions.chat() method is called on client with session.id and chatParams as arguments. The resultant object is stored in chatResponse.

The value of the content property is extracted from the chatResponse and stored in responseMessage.

Handling Error

To handle the errors, we will use the catch block to capture the error and display it

catch (error) {
    res.status(500).json({ error: error.message });
  }

Start the server

To start the server on localhost, we use the listen() method on app specifying the port number.

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

This will host the server on localhost:3000 and print the defined string in the console window.

Congratulations! Your AI app is successfully created.

Run the App

The project is completed, we will run it and try it.

To run the app, first, we will run the server.js file to initiate the Julep API and then the html file for the user interface.

Run this command to start the server:

node src/server.js

To run the React App, run this command:

npm run dev

This will run your project on the localhost. Here is the demo of the project:

Your app is running successfully.

Project link - https://github.com/ayush2390/julep-movio

Try out Movio - https://stackblitz.com/github/ayush2390/movio?file=README.md

Excited to see what more Julep offers? The journey starts with a single click. Visit the repository and give it a star: https://github.com/julep-ai/julep

Check out the tutorial for a deeper understanding of Julep.

Have any questions or feedback? Join the Julep Discord Community

discord.com

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.