Forem: Akshay Keerthi

Building a Natural Language to Java Generator using Lyzr Agent-Api

Akshay Keerthi — Wed, 21 Aug 2024 17:56:21 +0000

In today’s rapidly evolving tech landscape, developers are always on the lookout for tools that can simplify and speed up their coding process.

The Java Generator is one such innovative application that leverages the power of natural language processing, combined with the Lyzr Agent-API, to convert everyday language into Java code. Whether you’re a beginner or an expert, this tool makes coding more accessible than ever.

The Java Generator is designed to take user input in plain English and output accurate Java code. This application is built using Streamlit for the user interface and Lyzr Agent-API for natural language processing and code generation. Let’s walk through how this application works and explore the key components that make it tick.

Lets get started : Step-by-Step Explanation
Setting Up the Application

The application starts by importing the necessary libraries and loading the API keys from environment variables. Here’s the relevant snippet:

import os
from lyzr_agent import LyzrAgent
import streamlit as st
from dotenv import load_dotenv

load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
LYZR_API_KEY = os.getenv("LYZR_API_KEY")

This setup ensures that your API keys are securely stored and easily accessible when needed.

Initializing the LyzrAgent

The core functionality of the app lies in the LyzrAgent class, which interacts with the Lyzr Agent-API. The agent is initialized with the API keys and then configured to create a new environment for generating Java code based on natural language input.


Agent = LyzrAgent(
    api_key=LYZR_API_KEY,
    llm_api_key=OPENAI_API_KEY
)

This initialization is crucial as it sets the stage for the interaction between user inputs and the Lyzr API.

Creating the Agent and Environment

The create_agent function is where the magic happens. This function sets up an environment with specific features and tools, such as perplexity_search, which is used to find and synthesize relevant Java code based on the user’s input.

@st.cache_resource
def create_agent():
    env_id = Agent.create_environment(
        name="Post_java",
        features=[{
            "type": "TOOL_CALLING",
            "config": {"max_tries": 3},
            "priority": 0
        }],
        tools=["perplexity_search"]
    )

    agent_id = Agent.create_agent(
        env_id=env_id['env_id'],
        system_prompt=prompt,
        name="shell"
    )

This function sets up the environment where the agent will operate, including the tools it will use to generate the Java code.

User Input and Code Generation

The user interface allows the user to input their desired functionality in plain English. When the “Generate!” button is clicked, the input is sent to the Lyzr agent, which processes the input and returns the corresponding Java code.

query = st.text_area("Give your input in natural language below.")

if st.button("Generate!"):
    agent = create_agent()
    chat = Agent.send_message(
        agent_id=agent['agent_id'],
        user_id="default_user",
        session_id="akshay@lyzr.ai",
        message=query
    )

    st.markdown(chat['response'])

This code handles the interaction between the user and the agent, ensuring that the natural language input is accurately converted into Java code.

The Java Generator application demonstrates the incredible potential of natural language processing when combined with powerful APIs like Lyzr Agent-API.

By breaking down the barriers between natural language and code, this tool makes coding more intuitive and accessible for developers of all skill levels. Whether you’re looking to quickly prototype an idea or generate production-ready code, the Java Generator has you covered.

App link: https://lyzr-java.streamlit.app/

Source Code: https://github.com/isakshay007/java

For any inquiries or support, feel free to contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Home Décor Style Assistant using Lyzr Agent-API

Akshay Keerthi — Tue, 20 Aug 2024 17:47:05 +0000

Creating a personalized home décor style assistant can help users find the perfect style, products, and budget-friendly solutions for their spaces. In this blog post, we’ll walk through building a Home Décor Style Assistant using the Lyzr and Streamlit. This application will allow users to input their style preferences, room types, budget, and other specifics to receive tailored décor suggestions.

Prerequisites

Before diving in, make sure you have the following:

-Python 3.8 or higher installed.
-Lyzr SDK installed.
-Streamlit installed.
-A .env file containing your OPENAI_API_KEY and LYZR_API_KEY.

lyzr_agent.py: Interacting with the Lyzr API

The lyzr_agent.py file defines the LyzrAgent class, which serves as an interface to interact with the Lyzr API. This class provides methods to create environments, agents, and handle communication with the Lyzr platform.

Here’s a breakdown of the key components:

import requests
import json
class LyzrAgent:
    def __init__(self, api_key, llm_api_key):
        self.url = "https://agent.api.lyzr.app/v2/"
        self.headers = {
            "accept": "application/json",
            "x-api-key": api_key
        }
        self.llm_api_key = llm_api_key

Initialization: The constructor (init) initializes the API endpoint URL, the headers for API requests (including the Lyzr API key), and stores the OpenAI API key for later use.
Creating an Environment

def create_environment(self, name, features, tools):
    payload = json.dumps({
        "name": name,
        "features": features,
        "tools": tools,
        "llm_api_key": self.llm_api_key
    })
url = self.url + "environment"
    response = requests.post(url, headers=self.headers, data=payload)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

create_environment: This method creates a new environment within the Lyzr platform. It requires a name, a list of features, and tools. The environment is essential for setting up an agent that will handle specific tasks, like conducting searches or providing responses.
Creating an Agent

def create_agent(self, env_id, system_prompt, name):
    payload = json.dumps({
        "env_id": env_id,
        "system_prompt": system_prompt,
        "name": name,
        "agent_persona": "",
        "agent_instructions": "",
        "agent_description": ""
    })
url = self.url + "agent"
    response = requests.post(url, headers=self.headers, data=payload)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

create_agent: After creating an environment, we need an agent to perform tasks within that environment. This method sets up an agent with a specific prompt and name, which determines how it interacts with user inputs.

Sending a Message to the Agent

def send_message(self, agent_id, user_id, session_id, message):
    payload = json.dumps({
        "user_id": user_id,
        "agent_id": agent_id,
        "session_id": session_id,
        "message": message
    })
url = self.url + "chat/"
    response = requests.post(url, headers=self.headers, data=payload)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

send_message: This method allows us to send a message to the agent, which processes the user’s input and returns a response. The response will be used to generate the personalized décor suggestions.
Creating a Task

def create_task(self, agent_id, session_id, input_message):
    payload = json.dumps({
        "agent_id": agent_id,
        "session_id": session_id,
        "input": input_message
    })
url = self.url + "task"
    response = requests.post(url, headers=self.headers, data=payload)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

create_task: This method can be used to create specific tasks for the agent, such as conducting a detailed analysis or performing a complex operation based on user input.

app.py: Building the Streamlit Interface
The app.py file is where the magic happens. Here, we create a user interface with Streamlit, capture user inputs, and interact with the LyzrAgent to generate and display personalized home décor suggestions.

Setting Up the Streamlit Page

import os
from lyzr_agent import LyzrAgent
import streamlit as st
from dotenv import load_dotenv

load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
LYZR_API_KEY = os.getenv("LYZR_API_KEY")
st.set_page_config(
    page_title="Lyzr Home Décor Style",
    layout="centered",  # or "wide"
    initial_sidebar_state="auto",
    page_icon="lyzr-logo-cut.png",
)
st.title("Home Décor Style Assistant🏠")
st.markdown("### Welcome to the Home Décor Style Assistant!")

Streamlit Setup: We start by importing necessary libraries, loading environment variables, and configuring the Streamlit page with a title, layout, and icon. This sets the stage for our user-friendly interface.
Initializing the LyzrAgent

Agent = LyzrAgent(
    api_key=LYZR_API_KEY,
    llm_api_key=OPENAI_API_KEY
)

LyzrAgent Initialization: We create an instance of the LyzrAgent class, passing in our API keys. This agent will handle all backend interactions with the Lyzr platform.
Creating the Agent

@st.cache_resource
def create_agent():
    env_id = Agent.create_environment(
        name="Post_home",
        features=[{
            "type": "TOOL_CALLING",
            "config": {"max_tries": 3},
            "priority": 0
        }],
        tools=["perplexity_search"]
    )
    print(env_id)
prompt = """
[prompts here]
    """
    agent_id = Agent.create_agent(
        env_id=env_id['env_id'],
        system_prompt=prompt,
        name="home"
    )
    print(agent_id)
    return agent_id

create_agent Function: This function sets up the environment and agent with specific instructions on how to handle user inputs. The system_prompt guides the agent in its interactions, ensuring it delivers relevant and accurate home décor suggestions.
Handling User Input

query = st.text_area("Give your style preference, room type, budget, space dimensions, and other specifics like brand preference etc.")
if st.button("Assist!"):
    agent = create_agent()
    print(agent)
    chat = Agent.send_message(
        agent_id=agent['agent_id'],
        user_id="default_user",
        session_id="akshay@lyzr.ai",
        message=query
    )
    st.markdown(chat['response'])

User Interaction: We use Streamlit’s text_area to capture the user's décor preferences and specifics. When the "Assist!" button is clicked, the input is processed by the agent, and the resulting advice is displayed on the page.

By combining the power of Lyzr and Streamlit, we’ve created a responsive and intelligent Home Décor Style Assistant. This tool not only simplifies the process of home styling but also provides personalized, data-driven suggestions that cater to individual preferences.

App link: https://homestyle-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/home_style

For any inquiries or support, feel free to contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a LinkedIn Post Generator using Lyzr Agent-API

Akshay Keerthi — Tue, 20 Aug 2024 17:35:58 +0000

In this Blog, we’ll walk through building a LinkedIn Post Generator using the Lyzr SDK, Streamlit for the front-end interface.

This application will allow users to create and publish LinkedIn posts seamlessly by entering their text content and image URL.

We’ll utilize LyzrAgent to interact with Lyzr’s API and harness the power of AI for automating content generation and posting on LinkedIn.

Prerequisites:

Before diving into the code, ensure you have the following:

-Python 3.8 or higher installed.
-Lyzr SDK installed.
-Streamlit installed.
-An OpenAI API key and Lyzr API key.
-A .env file containing your API keys (OPENAI_API_KEY and LYZR_API_KEY).

Setting Up the Environment:

First, let’s set up our environment by loading the necessary libraries and API keys. We’ll create a .env file to securely store our API keys and use the dotenv library to load them into our application.

import os
from lyzr_agent import LyzrAgent
import streamlit as st
from dotenv import load_dotenv
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
LYZR_API_KEY = os.getenv("LYZR_API_KEY")

Creating the LyzrAgent:

The core of our application is the LyzrAgent, which will be responsible for creating environments, agents, and handling user inputs to generate and post content on LinkedIn.

Agent = LyzrAgent(
        api_key=LYZR_API_KEY,
        llm_api_key=OPENAI_API_KEY
    )

Building the Agent Environment:

We define a function create_agent() to set up the agent's environment. This environment is configured to use the TOOL_CALLING feature and will be equipped with a specific tool for posting images and text to LinkedIn.

@st.cache_resource
def create_agent():
    env_id = Agent.create_environment(
        name="Post_linkedin",
        features=[{
            "type": "TOOL_CALLING",
            "config": {"max_tries": 3},
            "priority": 0
        }],
        tools=["post_image_and_text_linkedin"]
    )
    print(env_id)
prompt = """
    You are an Expert Linkedin Post Creator. Your task is to compose and publish a LinkedIn post using the user provided Title, Image Url , and Text Content. You must follow these guidelines meticulously:
[prompts here]
    agent_id = Agent.create_agent(
        env_id=env_id['env_id'],
        system_prompt=prompt,
        name="Linkedin"
    )
    print(agent_id)
    return agent_id

Handling User Input:

We then use Streamlit’s text_area function to capture the user's input, including the post content and image URL. Upon clicking the "Generate" button, the app calls create_agent() to create an agent and uses the send_message function to generate the LinkedIn post.

query = st.text_area("Give the textual context of the post and the relevant image url.")
if st.button("Generate"):
    agent = create_agent()
    print(agent)
    chat = Agent.send_message(
        agent_id=agent['agent_id'],
        user_id="default_user",
        session_id="akshay@lyzr.ai",
        message=query
    )
    st.markdown(chat['response'])

Defining the LyzrAgent Class:

Finally, we define the LyzrAgent class in lyzr_agent.py. This class handles all interactions with the Lyzr API, including creating environments, agents, and sending messages.

import requests
import json
class LyzrAgent:
    def __init__(self, api_key, llm_api_key):
        self.url = "https://agent.api.lyzr.app/v2/"
        self.headers = {
            "accept": "application/json",
            "x-api-key": api_key
        }
        self.llm_api_key = llm_api_key
    def create_environment(self, name, features, tools):
        payload = json.dumps({
            "name": name,
            "features": features,
            "tools": tools,
            "llm_api_key": self.llm_api_key
        })
        url = self.url + "environment"
        response = requests.post(url, headers=self.headers, data=payload)
        if response.status_code == 200:
            return response.json()
        else:
            print(f"Error: {response.status_code} - {response.text}")
            return None
    def create_agent(self, env_id, system_prompt, name):
        payload = json.dumps({
            "env_id": env_id,
            "system_prompt": system_prompt,
            "name": name,
            "agent_persona": "",
            "agent_instructions": "",
            "agent_description": ""
        })
        url = self.url + "agent"
        response = requests.post(url, headers=self.headers, data=payload)
        if response.status_code == 200:
            return response.json()
        else:
            print(f"Error: {response.status_code} - {response.text}")
            return None
    def send_message(self, agent_id, user_id, session_id, message):
        payload = json.dumps({
            "user_id": user_id,
            "agent_id": agent_id,
            "session_id": session_id,
            "message": message
        })
        url = self.url + "chat/"
        response = requests.post(url, headers=self.headers, data=payload)
        if response.status_code == 200:
            return response.json()
        else:
            print(f"Error: {response.status_code} - {response.text}")
            return None
    def create_task(self, agent_id, session_id, input_message):
        payload = json.dumps({
            "agent_id": agent_id,
            "session_id": session_id,
            "input": input_message
        })
        url = self.url + "task"
        response = requests.post(url, headers=self.headers, data=payload)
        if response.status_code == 200:
            return response.json()
        else:
            print(f"Error: {response.status_code} - {response.text}")
            return None

With this setup, you’ve built a simple yet powerful LinkedIn Post Generator using Lyzr and Streamlit. The application takes user input, leverages the power of GPT-4 Turbo, and automates the process of creating and publishing LinkedIn posts.

App link: https://linkedinpost-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/Linkedin_Post

For any inquiries or support, feel free to contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Financial Literacy Assistant using Lyzr SDK

Akshay Keerthi — Tue, 20 Aug 2024 17:30:43 +0000

In today’s digital world, financial literacy is more important than ever. Whether you’re managing your own budget or helping others navigate their finances, having the right tools to simplify complex financial concepts can make all the difference. That’s where our Financial Literacy Assistant comes in.

This blog post will guide you through building a simple yet powerful Financial Literacy Assistant using Streamlit and Lyzr Automata. By the end of this tutorial, you’ll have a fully functional app that leverages the power of AI to help users understand personal finance better.

Prerequisites

Before diving into the code, ensure you have the following:

-Python installed on your machine.
-An OpenAI API key.
-Basic knowledge of Python and Streamlit.
-An understanding of how Lyzr Automata works (if not, check out their documentation).

Setting Up the Project

First, let’s start by importing the necessary libraries and setting up the environment:

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Here, we import Streamlit for creating the app's interface, OpenAIModel from Lyzr Automata to interact with GPT, and other essential modules for building the task pipeline.

Next, set up your OpenAI API key:

# Set the OpenAI API key
os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]
This ensures that your API key is securely stored and accessible when making API requests.

Implementing the AI Model

Next, we configure the OpenAI model, which will generate responses based on user input:

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

We create a function called generation() that utilizes Lyzr Automata to generate responses:

def generation(input):
    generator_agent = Agent(
        role="Expert FINANCIAL ADVISOR",
        prompt_persona=f"Your task is to EXPLAIN and EDUCATE users on PERSONAL FINANCE topics or questions. You MUST make the response as UNDERSTANDABLE and INFORMATIVE as possible, directly addressing the questions the user asks.")

    prompt = f"""
    You are an Expert FINANCIAL ADVISOR. Your task is to EXPLAIN and EDUCATE users on PERSONAL FINANCE topics or questions. You MUST make the response as UNDERSTANDABLE and INFORMATIVE as possible, directly addressing the questions the user asks.
    [prompts here]
    """
generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

This function sets up an agent with a specific role (Expert Financial Advisor) and instructions on how to generate the response.

Finally, we add a button that triggers the AI to generate a response when clicked:

if st.button("Assist!"):
    solution = generation(input)
    st.markdown(solution)

With just a few lines of code, we’ve created a Financial Literacy Assistant that can help users better understand and manage their finances. By leveraging the power of AI through Lyzr Automata and Streamlit, we’ve built an accessible and user-friendly tool that can make financial literacy more attainable for everyone.

App link: https://financeassistant-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/financial_advisor

For any inquiries or support, feel free to contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Public speaking Assistant using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 18:23:01 +0000

Public speaking can be daunting, but with the right preparation and practice, anyone can become a confident and engaging speaker. Our Public Speaking Assistant app, developed using Lyzr Automata SDK and OpenAI’s GPT-4 Turbo, provides personalized exercises tailored to your audience and speech type. This blog post will walk you through how we built this app to help you shine on stage.

Why use Lyzr SDK’s?
With Lyzr SDKs, crafting your own GenAI application is a breeze, requiring only a few lines of code to get up and running swiftly.

Lets get Started!

Setting Up the Environment

To begin, we import the necessary libraries and set up our environment, including configuring the OpenAI API key.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Set the OpenAI API key

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

Creating the App Title and Introduction

We then set the app’s title and provide a brief introduction to guide users on the information they need to input.

App title and introduction

st.title("Public Speaking Assistant")
st.markdown("Welcome to Tailored Public Speaking Exercises! Just tell us about your audience and the type of speech you're preparing for, and we'll give you custom drills to help you shine.")
st.markdown("1) Mention your audience type.")
st.markdown("2) Mention the type of speech you're preparing for.")
input = st.text_input("Please enter the above details:", placeholder="Type here")

Initializing the OpenAI Model

We initialize the OpenAI model with specific parameters for text completion. This model will generate personalized public speaking exercises.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

The generation function uses the OpenAI model to generate personalized public speaking exercises based on user input. It defines the agent's role and prompt for the task.

def generation(input):
    generator_agent = Agent(
        role="Expert PUBLIC SPEAKING ASSISTANT",
        prompt_persona="Your task is to ANALYZE the user's AUDIENCE and the TYPE of speech they are preparing for, and provide them with PERSONALIZED public speaking drills.")
    prompt = """
[Prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Adding the Assist Button

We add a button that triggers the generation of personalized exercises when clicked.

if st.button("Assist!"):
    solution = generation(input)
    st.markdown(solution)

The Public Speaking Assistant app helps users enhance their public speaking skills by providing personalized exercises based on their audience and speech type. Leveraging the power of Lyzr Automata SDK and OpenAI’s GPT-4 Turbo, this app offers a practical solution for anyone looking to improve their public speaking abilities.

App link: https://speakingassistant-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/speaking_assistant

Try building your own version of the Public Speaking Assistant app and experience the benefits of AI-driven personalized exercises! If you have any questions or need further assistance, feel free to contact Lyzr.

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a To-Do List Generator using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 18:10:23 +0000

Organizing your tasks effectively can significantly boost productivity and reduce stress. To help users achieve this, I created a To-Do List Generator app using Lyzr Automata SDK and OpenAI’s GPT-4 Turbo. This app takes your project name, subtasks, and any additional notes to generate a clear and actionable to-do list. Here’s a step-by-step guide to building this helpful app.

Setting Up the Environment

First, we need to import the required libraries and set up the environment, including the OpenAI API key.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Set the OpenAI API key

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

Creating the App Title and Introduction

We then set the title and provide a brief introduction to guide users on what information they need to input.

st.title("To-Do List Generator📝")
st.markdown("Welcome! Effortlessly organize your tasks with our intuitive to-do list generator. Simply provide the main project name and a few subtasks, and we'll create a clear and actionable list for you.")
st.markdown("1) Mention your Task Name.")
st.markdown("2) Mention your Subtasks.")
st.markdown("3) Mention any additional notes or comments.")
input = st.text_input("Please enter the above details:", placeholder="Type here")

Initializing the OpenAI Model

We initialize the OpenAI model with specific parameters for text completion. This model will generate the to-do list.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

The generation function uses the OpenAI model to generate a comprehensive to-do list based on user input. The function defines the agent's role and prompt for the task.

def generation(input):
    generator_agent = Agent(
        role="Expert TO-DO LIST ORGANIZER",
        prompt_persona="Your task is to CREATE a COMPREHENSIVE to-do list based on the DETAILS provided by the user, including TASK NAME, SUBTASKS, and any additional NOTES.")
    prompt = """
[Prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Adding the Generate Button

We add a button that triggers the generation of the to-do list when clicked.

if st.button("Generate!"):
    solution = generation(input)
    st.markdown(solution)

The To-Do List Generator app helps users create organized and actionable to-do lists by analyzing their task names, subtasks, and additional notes. Leveraging the power of Lyzr Automata SDK and OpenAI’s GPT-4 Turbo, this app provides a practical solution for efficient task management.

App link: https://to-dogenerator-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/To-do_Generator

Try building your own version of the To-Do List Generator app and experience the benefits of AI-driven task organization! If you have any questions or need further assistance, feel free to contact Lyzr.

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Cybersecurity Assistant using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 18:06:59 +0000

In today’s digital age, cybersecurity is paramount. To help individuals safeguard their online activities and devices, I developed a Cybersecurity Assistant app using Lyzr Automata SDK and OpenAI’s GPT-4 Turbo. This blog post walks you through the creation of this app, which provides personalized cybersecurity tips and a custom security checklist based on user input.

Why use Lyzr SDK’s?

With Lyzr SDKs, crafting your own GenAI application is a breeze, requiring only a few lines of code to get up and running swiftly.

Lets get Started!

Setting Up the Environment

To start, we need to import the necessary libraries and set up the environment, including the OpenAI API key.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Set the OpenAI API key

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

Creating the App Title and Introduction

We then set the title and provide a brief introduction to guide the users on what information they need to input.

st.title("Cybersecurity Assistant")
st.markdown("Welcome to Cybersecurity Assistant, your personalized cybersecurity advisor. Simply input your online activities and your device specification, and receive tailored tips to keep your digital life secure and protected.")
st.markdown("1) Mention your online activities (websites visited, download habits, device and network usage etc).")
st.markdown("2) Mention your device specifications.")
input = st.text_input("Please enter the above details:", placeholder="Type here")

Initializing the OpenAI Model

We initialize the OpenAI model with specific parameters for text completion. This model will generate the personalized cybersecurity advice.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

The generation function uses the OpenAI model to generate personalized cybersecurity tips and a custom security checklist based on user input. The function defines the agent's role and prompt for the task.

def generation(input):
    generator_agent = Agent(
        role="Expert CYBERSECURITY CONSULTANT",
        prompt_persona="Your task is to DEVELOP Personalized Security Tips and CREATE a Custom Security Checklist tailored to an individual's online activities and device specifications.")
    prompt = """
[Prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Adding the Assist Button

if st.button("Assist!"):
    solution = generation(input)
    st.markdown(solution)

The Cybersecurity Assistant app helps users receive personalized cybersecurity advice by analyzing their online activities and device specifications. By leveraging the power of Lyzr Automata SDK and OpenAI’s GPT-4 Turbo, this app provides practical and actionable security tips to keep users’ digital lives secure.

App link: https://cybersecurityassistant-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/cybersecurity_assistant

Feel free to try building your own version of the Cybersecurity Assistant app and explore the potential of AI-driven cybersecurity solutions! If you have any questions or need further assistance, don’t hesitate to contact Lyzr.

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Personalized Freelance Assistant using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 18:03:27 +0000

Freelancing offers a world of opportunities and flexibility, but it also comes with its own set of challenges. The Personalized Freelance Assistant app aims to provide tailored tips and strategies to help freelancers succeed in their careers. Leveraging the Lyzr Automata SDK and OpenAI’s GPT-4 Turbo, this app creates customized plans based on user input.

Setting Up the Environment

First, we need to import the necessary libraries and set up our environment.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Setting the OpenAI API Key

We need to set the OpenAI API key to access the GPT-4 Turbo model.

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

App Title and Introduction

Next, we set the title of our app and provide a brief introduction to guide users on how to use the Personalized Freelance Assistant.

st.title("Freelance Assistant")
st.markdown("Welcome to Freelance Assistant, your personalized freelancing guide. Enter your career details and goals for customized tips and strategies to enhance your freelance journey.")
st.markdown("1) Mention your field of expertise.")
st.markdown("2) Mention your experience level.")
st.markdown("3) Mention your income goals.")
st.markdown("4) Mention your preferred work-life balance.")
input = st.text_input("Please enter the above details:", placeholder="Type here")

Setting Up the OpenAI Model

We initialize the OpenAI model with specific parameters to generate personalized freelancing advice based on user input.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

This function uses the Lyzr Automata SDK to create an agent that provides personalized freelancing advice based on the user’s input.

def generation(input):
    generator_agent = Agent(
        role="Expert FREELANCING CONSULTANT",
        prompt_persona=f"Your task is to OFFER personalized freelancing tips and strategic advice that aligns with the user's specific details.")
    prompt = f"""
[prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Button to Generate Freelancing Advice

We add a button that triggers the generation of personalized freelancing tips and strategies when clicked.

if st.button("Assist!"):
    solution = generation(input)
    st.markdown(solution)

The Freelance Assistant app is designed to provide personalized tips and strategies to help freelancers enhance their careers. By leveraging the power of Lyzr Automata and OpenAI’s GPT-4 Turbo, users can receive expert advice tailored to their specific career details and goals. Explore the Freelance Assistant today and take your freelancing journey to the next level!

App link: https://freelanceassistant-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/freelance_assistant

For any inquiries or support, feel free to contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Personalized Gift Assistant using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 17:57:51 +0000

Finding the perfect gift can be challenging, especially when considering the recipient’s unique interests, the occasion, and your budget. The Personalized Gift Assistant app is here to make this process easier and more enjoyable. Leveraging the power of Lyzr Automata and OpenAI’s GPT-4 Turbo, this app helps you curate personalized gift recommendations that are sure to delight any recipient.

Setting Up the Environment

First, let’s import the necessary libraries and set up our environment.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Setting the OpenAI API Key

We need to set the OpenAI API key to access the GPT-4 Turbo model.

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

App Title and Introduction

We set the title of our app and provide a brief introduction to guide users on how to use the Personalized Gift Assistant.

st.title("Personalized Gift Assistant")
st.markdown("Welcome to Personalized Gift Assistant! Let us help you find the perfect gift for any occasion, tailored to your recipient's unique interests and your budget.")
st.markdown("1) Mention your receiver's age.")
st.markdown("2) Mention your receiver's interest.")
st.markdown("3) Mention the occasion.")
st.markdown("4) Mention your budget.")
input = st.text_input("Please enter the above details:", placeholder="Type here")

Setting Up the OpenAI Model

We initialize the OpenAI model with specific parameters to generate personalized gift recommendations based on user input

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

This function uses the Lyzr Automata SDK to create an agent that provides personalized gift recommendations based on the user’s input.

def generation(input):
    generator_agent = Agent(
        role="Expert GIFT CONSULTANT",
        prompt_persona="Your task is to CURATE a personalized list of 5-7 GIFTS for the user and provide EXPLANATIONS for each choice, taking into account the RECEIVER'S AGE, RECEIVER'S INTERESTS, the OCCASION, and the BUDGET.")
    prompt = """
[Prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Button to Generate Gift Recommendations

We add a button that triggers the generation of personalized gift recommendations when clicked.

if st.button("Assist!"):
    solution = generation(input)
    st.markdown(solution)

The Personalized Gift Assistant is designed to help you find the perfect gift for any occasion. By leveraging the power of Lyzr Automata and OpenAI’s GPT-4 Turbo, you can receive expert recommendations tailored to the recipient’s age, interests, occasion, and your budget. Explore the Personalized Gift Assistant today and make gift-giving a delightful experience!

App link: https://giftassistant-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/gift_assistant

For any inquiries or support, feel free to contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Productivity Assistant using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 17:51:29 +0000

In our fast-paced world, staying productive can often be challenging. With numerous tasks to juggle and goals to achieve, finding the right balance can be overwhelming. Enter the Productivity Assistant, an innovative app designed to provide personalized tips and actionable advice tailored to your specific needs. Powered by Lyzr Automata and OpenAI’s GPT-4 Turbo, this app is here to help you overcome productivity challenges and achieve your goals efficiently. Let’s delve into how this app works and how you can make the most of it.

Why Use the Productivity Assistant?

The Productivity Assistant is designed to analyze your daily routine, identify productivity challenges, and provide customized recommendations to help you achieve your short-term and long-term goals. Whether you’re struggling with time management, motivation, or prioritization, this app offers practical advice that you can implement immediately to enhance your productivity.

Setting Up the Environment

To get started, we set up our environment using Streamlit and the Lyzr Automata SDK. Streamlit is a powerful framework for creating interactive web applications in Python, while Lyzr Automata provides tools for leveraging advanced AI models.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Setting the OpenAI API Key

To access the GPT-4 Turbo model, we need to set the OpenAI API key.

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

App Title and Introduction

We begin by setting the title of our app and providing a brief introduction to guide users on how to use the Productivity Assistant.

st.title("Productivity Assistant👨‍💻")
st.markdown("Welcome to Productivity Assistant! We provide personalized tips and actionable advice to help you overcome challenges and achieve your specific goals efficiently.")
st.markdown("1) Mention your daily routine.")
st.markdown("2) Mention the productivity challenges you face.")
st.markdown("3) Mention your goals (Short Term or Long Term) or any other milestones you want to achieve if any.")
input = st.text_input("Please enter the above details:", placeholder="Type here")

Setting Up the OpenAI Model

We initialize the OpenAI model with specific parameters to generate personalized productivity advice based on user input.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

This function uses the Lyzr Automata SDK to create an agent that provides personalized productivity tips based on the user’s daily routine, productivity challenges, and goals.

def generation(input):
    generator_agent = Agent(
        role="Expert PRODUCTIVITY ASSISTANT",
        prompt_persona="Your task is to offer PERSONALIZED PRODUCTIVITY TIPS and ACTIONABLE RECOMMENDATIONS tailored to an individual's DAILY ROUTINE, the PRODUCTIVITY CHALLENGES they encounter, and their GOALS—whether SHORT-TERM or LONG-TERM—or any other MILESTONES they aim to achieve.")
    prompt = """
[prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Button to Generate Productivity Advice

We add a button that triggers the generation of personalized productivity advice when clicked.

if st.button("Assist!"):
    solution = generation(input)
    st.markdown(solution)

The Productivity Assistant is designed to provide you with practical, feasible, and personalized productivity tips and recommendations. By leveraging the power of Lyzr Automata and OpenAI’s GPT-4 Turbo, you can receive expert advice tailored to your unique circumstances, helping you overcome challenges and achieve your goals efficiently. Whether you’re looking to improve your time management, increase your motivation, or prioritize your tasks better, the Productivity Assistant is here to support you.

App link: https://assistant-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/productivity_assistant

The Productivity Assistant app is powered by the Lyzr Automata Agent, utilizing the capabilities of OpenAI’s GPT-4 Turbo. For any inquiries or issues, please contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building NL2PHP using Lyzr SDK

Akshay Keerthi — Tue, 06 Aug 2024 17:43:02 +0000

In the world of software development, translating ideas from natural language into functional code can often be a challenging and time-consuming process. But what if you could streamline this process with the help of advanced AI tools? Welcome to NL2PHP, an innovative app designed to transform your natural language instructions into accurate PHP code effortlessly.

Leveraging the capabilities of Lyzr Automata and OpenAI’s GPT-4 Turbo, NL2PHP is here to make coding more accessible for everyone, from beginners to experienced developers. Let’s explore how this app works and how you can use it to convert your ideas into ready-to-use PHP code in seconds.

Why Use NL2PHP?

NL2PHP simplifies the coding process by allowing you to describe what you want in natural language. The app then translates your instructions into precise PHP code. This approach is particularly useful for those who might find writing code from scratch daunting or time-consuming.

By using NL2PHP, you can focus on what you want to achieve without worrying about the intricate details of PHP syntax.

Setting Up the Environment

Before diving into how NL2PHP works, let’s set up our environment using Streamlit and the Lyzr Automata SDK. Streamlit is a powerful framework for creating interactive web applications in Python, while Lyzr Automata provides tools for leveraging advanced AI models.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Setting the OpenAI API Key

To access the GPT-4 Turbo model, we need to set the OpenAI API key.

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

App Title and Introduction

We begin by setting the title of our app and providing a brief introduction to guide users on how to use NL2PHP.

st.title("NL2PHP🧑🏻‍💻")
st.markdown("Welcome to NL2PHP! This app effortlessly transforms your natural language instructions into functional PHP code. Whether you're a beginner or an experienced developer, convert your ideas into ready-to-use code in seconds.")
input = st.text_input("Please enter in natural language:", placeholder="Type here")

Setting Up the OpenAI Model

We initialize the OpenAI model with specific parameters to generate the PHP code based on user input.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

This function uses the Lyzr Automata SDK to create an agent that translates natural language input into PHP code.

def generation(input):
    generator_agent = Agent(
        role="Expert PHP DEVELOPER",
        prompt_persona="Your task is to TRANSLATE the natural language input from the user into ACCURATE PHP CODE.")
    prompt = """
[prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Button to Generate the PHP Code

We add a button that triggers the generation of the PHP code when clicked.

if st.button("Convert!"):
    solution = generation(input)
    st.markdown(solution)

NL2PHP represents a significant step forward in making coding more accessible and efficient. By leveraging the power of Lyzr Automata and OpenAI’s GPT-4 Turbo, you can transform your natural language instructions into functional PHP code quickly and accurately. This tool is perfect for both beginners who are learning to code and experienced developers looking to speed up their workflow.

App link: https://nl2php-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/NL2PHP

The NL2PHP app is powered by the Lyzr Automata Agent, utilizing the capabilities of OpenAI’s GPT-4 Turbo. For any inquiries or issues, please contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Building a Custom PC Guide using Lyzr SDK

Akshay Keerthi — Mon, 05 Aug 2024 12:27:57 +0000

In today’s tech-savvy world, having a custom-built PC tailored to your specific needs and budget can make all the difference. Whether you’re a gamer, a professional, or someone who simply wants a powerful machine, building a PC can be both a rewarding and cost-effective endeavor. With advancements in AI and natural language processing, tools like Lyzr Automata and OpenAI’s GPT-4 Turbo make this process even more accessible. Let’s dive into how you can build your custom PC using these powerful tools.

Why use Lyzr SDK’s?

With Lyzr SDKs, crafting your own GenAI application is a breeze, requiring only a few lines of code to get up and running swiftly.

Checkout the Lyzr SDK’s

Lets get Started!
Setting Up the Environment

First, we set up our environment using Streamlit and the Lyzr Automata SDK. Streamlit is a framework for creating interactive web applications in Python, and Lyzr Automata provides tools for leveraging AI models.

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from lyzr_automata.tasks.task_literals import InputType, OutputType
import os

Setting the OpenAI API Key

We need to set the OpenAI API key to authenticate and access the GPT-4 Turbo model.

os.environ["OPENAI_API_KEY"] = st.secrets["apikey"]

App Title and Introduction

We set the title and provide a brief introduction to guide users on how to use the app.

st.title("Custom PC Build Guide")
st.markdown("Welcome to the Custom PC Build Guide! Tell us your budget and what you need, and we'll help you build the perfect PC, tailored just for you.")
st.markdown("            1) Determine Your Budget.")
st.markdown("            2) Mention your needs (Primary Use,Preferred Brands if any and etc).")
st.markdown("            3) Provide additional information if any like Such as RGB lighting, quiet operation, overclocking capabilities, etc.")
input = st.text_input(" Please enter the above details:", placeholder="Type here")

Setting Up the OpenAI Model

We initialize the OpenAI model with specific parameters for generating the PC build guide.

open_ai_text_completion_model = OpenAIModel(
    api_key=st.secrets["apikey"],
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

Defining the Generation Function

This function uses the Lyzr Automata SDK to create an agent that guides users through the PC building process.

def generation(input):
    generator_agent = Agent(
        role="Expert PC BUILDER and CUSTOMIZATION CONSULTANT",
        prompt_persona="Your task is to GUIDE users through the process of building their own CUSTOMIZED PC, tailored to their budget and specific needs, including primary use, preferred brands, and additional requirements such as RGB lighting, quiet operation, overclocking capabilities, etc.")
    prompt = """
[Prompts here]
"""
    generator_agent_task = Task(
        name="Generation",
        model=open_ai_text_completion_model,
        agent=generator_agent,
        instructions=prompt,
        default_input=input,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
    ).execute()
    return generator_agent_task

Button to Generate the Guide

We add a button that triggers the generation of the PC build guide when clicked.

if st.button("Guide!"):
    solution = generation(input)
    st.markdown(solution)

Building a custom PC can seem daunting at first, but with the right guidance and tools, it becomes a manageable and even enjoyable task. By leveraging the capabilities of Lyzr Automata and OpenAI’s GPT-4 Turbo, you can receive expert advice tailored to your specific needs and budget. This app not only helps you choose the right components but also provides clear, step-by-step instructions to assemble your PC.

With the power of AI, you can ensure that your custom PC build meets your performance requirements, aesthetic preferences, and budget constraints. Whether you’re a gamer, a professional, or simply a tech enthusiast, this guide aims to simplify the process and make your custom PC building experience as smooth as possible.

App link: https://custompc-lyzr.streamlit.app/

Source Code: https://github.com/isakshay007/Custom_PC

The Custom PC Guide is powered by the Lyzr Automata Agent, utilizing the capabilities of OpenAI’s GPT-4 Turbo. For any inquiries or issues, please contact Lyzr. You can learn more about Lyzr and their offerings through the following links:

Website: Lyzr.ai
Book a Demo: Book a Demo
Discord: Join our Discord community
Slack: Join our Slack channel

Feel free to explore the app, provide your details, and start building the PC of your dreams. Happy building!