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

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