Month: June 2024

In my previous article I presented results comparing Anthropic Claude 3.5 Sonnet and OpenAI GPT-4o models for zero-shot text classification. The results showed that the Claude 3.5 Sonnet significantly outperformed GPT-4o.

These results motivated me to develop a simple retrieval augmented generation system with LangChain that enables the Claude 3.5 Sonnet model to answer questions pertaining to custom documents.

By the end of this article, you will know how to develop a chatbot that uses the Claude 3.5 Sonnet LLM to answer questions on custom documents.

So, let's begin without ado.

The following script installs the libraries required to run scripts in this article.

!pip install -U langchain
!pip install -U langchain-anthropic
!pip install langchain-openai
!pip install pypdf
!pip install faiss-cpu

Subsequently, the script below imports the required libraries into your Python application.

from langchain_anthropic import ChatAnthropic

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain
from langchain_core.documents import Document
from langchain.chains import create_history_aware_retriever
from langchain_core.prompts import MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
import os

Let's first generate a default response using Claude 3.5 Sonnet LLM in LangChain.

You will need an anthropic API key which you can get here.

Next, create an object of the ChatAnthropic class and pass the anthropic API key, the model ID, and the temperature value to its constructor. The temperature specifies how creative a model should be while generating responses. Higher temperature values allow models to be more creative.

Finally, pass the prompt to the invoke() method of the ChatAnthropic object to generate the model response.

anthropic_api_key = os.environ.get('ANTHROPIC_API_KEY')

llm = ChatAnthropic(model="claude-3-5-sonnet-20240620",
                     anthropic_api_key = anthropic_api_key,
                     temperature = 0.3)

result = llm.invoke("Write a funny poem for an ice cream shop on a beach.")
print(result.content)

Output:

The LangChain ChatPromptTemplate class allows you to create a chatbot. The from_messages() method indicates that the conversation should be executed in message format. In this setup, you must specify the value for the user attribute, while the system attribute is optional.

You can use the StrOutputParser class to parse the model response in string format, as shown in the script below:

prompt = ChatPromptTemplate.from_messages([
    ("system", '{assistant}'),
    ("user", "{input}")
])

output_parser = StrOutputParser()

chain = prompt | llm | output_parser

result = chain.invoke(
    {"assistant": "You are a comedian",
     "input": "Write a funny poem for a music store on a beach."}
)
print(result)

Output:

Now you know how to call the Claude 3.5 Sonnet LLM in LangChain. In this section, we will augment the Claude 3.5 Sonnet model's knowledge, making it capable of answering questions related to the documents it had not seen during training.

We start by loading and splitting the document using PyPDFLoader. In this case, we load "The English Constitution" by Walter Bagehot from a URL.

The following script's load_and_split() method ensures the document is parsed correctly and divided into manageable sections.

loader = PyPDFLoader("https://web.archive.org/web/20170809122528id_/http://global-settlement.org/pub/The%20English%20Constitution%20-%20by%20Walter%20Bagehot.pdf")
docs = loader.load_and_split()

Next, we create embeddings for the text using OpenAI API's OpenAIEmbeddings class. We then split the text into smaller chunks with RecursiveCharacterTextSplitter and created a FAISS vector store using the split documents and their embeddings. This step transforms the text into a format suitable for retrieval and similarity search.

openai_key = os.environ.get('OPENAI_API_KEY')

embeddings = OpenAIEmbeddings(openai_api_key = openai_key)

text_splitter = RecursiveCharacterTextSplitter()
documents = text_splitter.split_documents(docs)
vector = FAISS.from_documents(documents, embeddings)

The next step is to define a prompt template using the ChatPromptTemplate class. The template instructs the model to answer questions based solely on the provided context, ensuring accurate and relevant responses. The create_stuff_documents_chain function links this template with the language model, forming a document chain that will be used for generating responses.

prompt = ChatPromptTemplate.from_template("""Answer the following question based only on the provided context:

Question: {input}

Context: {context}
"""
)

document_chain = create_stuff_documents_chain(llm, prompt)

We convert the vector store into a retriever object with vector.as_retriever() method. The retriever, combined with the document chain, forms a retrieval_chain. This setup enables the system to fetch relevant document sections based on the user's query and use them as context for generating answers.

retriever = vector.as_retriever()
retrieval_chain = create_retrieval_chain(retriever, document_chain)

Finally, we define the generate_response() function that takes a query as input, invokes the retrieval chain, and prints the answer.

def generate_response(query):
    response = retrieval_chain.invoke({"input": query})
    print(response["answer"])

To demonstrate the system in action, we run a few example queries as shown below:

Query1:

query = "What is the total number of members of the house of commons?"
generate_response(query)

Output:

Query2:

query = "What is the difference between the house of lords and house of commons? How members are elected for both?"
generate_response(query)

Output:

Query3:

query = "How many players participate in a football game?"
generate_response(query)

Output:

You can see that the model correctly replied to queries related to custom document and refused to generate response to questions that are not related to the document.

The retrieval augmented generation (RAG) technique has revolutionized the development of customized chatbots for various data sources. In this article, we demonstrated how to build a chatbot using the Claude 3.5 Sonnet model to answer questions based on previously unseen documents. This method can be applied to create chatbots capable of querying diverse data types such as PDFs, websites, text documents, and beyond.

I encourage you to leverage Claude 3.5 Sonnet to develop your custom chatbots, explore its powerful capabilities, and share your experience and feedback in the comments section.

On June 20, 2024, Anthropic released the Claude 3.5 sonnet large language model. Claude claims it to be the state-of-the-art model for many natural language processing tasks, surpassing the OpenAI GPT-4o model.

My first test for comparing two large language models is their zero-shot text classification ability. In this article, I will compare the Antropic Claude 3.5 sonnet with the OpenAI GPT-4o model for zero-shot tweet sentiment classification.

So, let's begin without ado.

The following script installs the Anthropic and OpenAI libraries to access the corresponding APIs.

!pip install anthropic
!pip install openai

The script below imports the required libraries into your Python application.

import os
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import anthropic
from openai import OpenAI

We will use the Twitter US Airline Sentiment dataset to perform zero-shot classification. You can download the dataset from Kaggle.

The following script imports the dataset into a Pandas DataFrame.

## Dataset download link
## https://www.kaggle.com/datasets/crowdflower/twitter-airline-sentiment?select=Tweets.csv

dataset = pd.read_csv(r"D:\Datasets\tweets.csv")
print(dataset.shape)
dataset.head()

Output:

Tweet sentiment falls into three categories: neutral, positive, and negative. For comparison, we will filter 100 tweets. The neutral, positive, and negative categories will contain 34, 33, and 33 tweets, respectively.

# Remove rows where 'airline_sentiment' or 'text' are NaN
dataset = dataset.dropna(subset=['airline_sentiment', 'text'])

# Remove rows where 'airline_sentiment' or 'text' are empty strings
dataset = dataset[(dataset['airline_sentiment'].str.strip() != '') & (dataset['text'].str.strip() != '')]

# Filter the DataFrame for each sentiment
neutral_df = dataset[dataset['airline_sentiment'] == 'neutral']
positive_df = dataset[dataset['airline_sentiment'] == 'positive']
negative_df = dataset[dataset['airline_sentiment'] == 'negative']

# Randomly sample records from each sentiment
neutral_sample = neutral_df.sample(n=34)
positive_sample = positive_df.sample(n=33)
negative_sample = negative_df.sample(n=33)

# Concatenate the samples into one DataFrame
dataset = pd.concat([neutral_sample, positive_sample, negative_sample])

# Reset index if needed
dataset.reset_index(drop=True, inplace=True)

# print value counts
print(dataset["airline_sentiment"].value_counts())

Output:

We will first perform zero-shot text classification with GPT-4o. Remember to get your OpenAI API key before executing the following script.

The script below defines a function find_sentiment() that accepts the client and model parameters. The client corresponds to the client, i.e., anthropic or OpenAI, while the model corresponds to Claude 3.5 Sonnet or GPT-4o.

The find_sentiment() function iterates through all the tweets from the filtered dataset and predicts sentiment for each tweet. The predicted sentiments are then compared with the actual sentiment values to determine the model's accuracy.

def find_sentiment(client, model):

    tweets_list = dataset["text"].tolist()


    all_sentiments = []

    i = 0
    exceptions = 0
    while i < len(tweets_list):

        try:
            tweet = tweets_list[i]
            content = """What is the sentiment expressed in the following tweet about an airline?
            Select sentiment value from positive, negative, or neutral. Return only the sentiment value in small letters.
            tweet: {}""".format(tweet)

            sentiment_value = client.chat.completions.create(
                                  model= model,
                                  temperature = 0,
                                  max_tokens = 10,
                                  messages=[
                                        {"role": "user", "content": content}
                                    ]
                                ).choices[0].message.content

            all_sentiments.append(sentiment_value)
            i = i + 1
            print(i, sentiment_value)

        except Exception as e:
            print("===================")
            print("Exception occurred:", e)
            exceptions += 1

    print("Total exception count:", exceptions)
    accuracy = accuracy_score(all_sentiments, dataset["airline_sentiment"])
    print("Accuracy:", accuracy)

Next, we create an OpenAI client and pass the client object along with the gpt-4o model to predict sentiments.

%%time
client = OpenAI(
    # This is the default and can be omitted
    api_key = os.environ.get('OPENAI_API_KEY'),
)
model = "gpt-4o"

find_sentiment(client, model)

Output:

The above output shows that GPT-4o achieved an accuracy of 76%.

Let's now predict the sentiment for the same set of tweets using the Claude 3.5 sonnet model. We define the find_sentiment_claude() function which is similar to the find_sentiment() function, but predicts sentiments using the Claude 3.5 sonnet model.

def find_sentiment_claude(client, model):

    tweets_list = dataset["text"].tolist()


    all_sentiments = []

    i = 0
    exceptions = 0
    while i < len(tweets_list):

        try:
            tweet = tweets_list[i]
            content = """What is the sentiment expressed in the following tweet about an airline?
            Select sentiment value from positive, negative, or neutral. Return only the sentiment value in small letters.
            tweet: {}""".format(tweet)

            sentiment_value = client.messages.create(
                                model= model,
                                max_tokens=10,
                                temperature=0.0,
                                messages=[
                                    {"role": "user", "content": content}
                                ]
                            ).content[0].text

            all_sentiments.append(sentiment_value)
            i = i + 1
            print(i, sentiment_value)

        except Exception as e:
            print("===================")
            print("Exception occurred:", e)
            exceptions += 1

    print("Total exception count:", exceptions)
    accuracy = accuracy_score(all_sentiments, dataset["airline_sentiment"])
    print("Accuracy:", accuracy)

The script below calls the find_sentiment_claude() function using the anthropic client and the claude-3-5-sonnet-20240620 (the id for the Claude 3.5 sonnet) model.

%%time
client = anthropic.Anthropic(
    # defaults to os.environ.get("ANTHROPIC_API_KEY")
    api_key = os.environ.get('ANTHROPIC_API_KEY')
)

model = "claude-3-5-sonnet-20240620"

find_sentiment_claude(client, model)

Output:

The above output shows that the Claude 3.5 Sonnet model achieved an accuracy of 83%, which is significantly better than the GPT-4o model.

Here is an overall comparison between the Claude Sonnet 3.5 and the GPT-4o model.

Given the price, performance, and context window size, I prefer the Claude 3.5 Sonnet over other proprietary models such as GPT-4o.

Feel free to share your opinions. I would be very interested in any results you obtain using the two models.

Planning to sell courses online this year? Or perhaps you’re looking for a better way to track and manage employee training? Either way, you’ll need a learning management system...

The post The 6 Best LMS Systems & Tools for 2024 appeared first on Onextrapixel.

Technology has become a dominant force in how we interact and operate. Now more than ever, we need to be aware of the dangers of centralization including the risks of overdependency.

What do Facebook and North Korea have in common? They're both heavily centralized systems. The dangers of over-centralization were highlighted just a few years ago when a single server failure at a Meta data center in California caused a global outage for Facebook, Instagram, WhatsApp, and other services. With corporate AI on the rise and ChatGPT poised to become an integral part of your iPhone, it's time to take a closer look at centralized systems and their inherent vulnerabilities.

So, buckle up for an excursion into the domain of system theory, where we will explore the fundamental differences between centralized and decentralized organization and uncover what makes centralized systems so vulnerable. Armed with this knowledge, we'll ponder whether concentrating AI development in the hands of a few corporate giants is a smart move or a recipe for waking up in a Philip K. Dick novel.

System science aims to understand the function of different components within complex systems to enhance overall efficiency and reliability. My first encounter with this field was when blockchain technology emerged. Heres an excerpt from an article I wrote at that time, which should clarify the concept of centralization versus decentralization and why blockchain was a revolutionary concept for system scientists (although the latter is not the point of this article)

Try asking Google whether the earth is flat. The answer is clearly a simple no, but the search results will include plenty of dissenting opinions. This is because the Internet is decentralized in both its organization and logic. The fact that it is not subject to a central authority has many advantages, but also means that there is no one to vouch for any of the information it offers.

Most states are the polar opposite of this, they have a centralized logic and organization. They are subject to the control of an institution (i.e. the government) that vouches for content and prescribes procedures (e.g. through laws).

Then there are systems with centralized organization and decentralized logic. They are managed institutionally but allow for individual use. A Word file is a good example, as it can be processed on any computer outfitted with the same software. The workflows are predefined by the program, while the contents can be individually edited by each user.

This is the system theory that underlies our experience of everyday life. A fourth option a system that is logically centralized and organizationally decentralized, hence independent and yet reliable seemed improbable. Then along came blockchain.

Source: Goethe Institute

Many corporations today incorporate processes that are logically decentralized (e.g., independent decision-making within departments) yet they are organizationally centralized, making their components heavily interdependent. Such centralized corporate structures have advantages, including clear command chains and streamlined processes. However, their vulnerability and over-dependence by users pose significant risks.

At the heart of the debate between centralization and decentralization lies the question of efficient resource management, with centralized systems often claiming greater efficiency. For instance, its more straightforward for everyone to line up at the school cafeteria and receive their lunch rather than everyone preparing their own meal individually. However, the academic debate on whether centralized or decentralized systems are more efficient remains unresolved and varies depending on the type of system in question. Its important to clarify that my focus on centralization here concerns globally available services controlled by a handful of large corporate entities. So, we're not discussing the logistics within a single school cafeteria, but rather a hypothetical global network of cafeterias relying on a singular distribution chain, where one point of failure could leave all kids without lunch.

This leads us to a fundamental issue that renders centralized systems highly vulnerable: if the central node is compromised or fails, the entire system collapsesa single point of failure can bring down the whole network. Consider the example of GPS. Whether you use Google Maps, Waze, or another navigation app, they all depend on GPS. If GPS were to fail due to a cyberattack or another unforeseen issue, youd better know how to read a map.

In addition to risks associated with single points of failure and overdependency, centralized systems have other significant drawbacks. They can stifle innovation, reduce operational flexibility, create bureaucratic inefficiencies, and limit responsiveness to individual needs. Furthermore, the concentration of power within centralized systems can make them not just vulnerable but also potentially dangerous. Economist Leopold Kohr, who fled the Nazi regime, devoted his life to arguing that overly large systems are the root of many societal evils. In his book The Breakdown of Nations (1957), he states:

there seems only one cause behind all forms of social misery: bigness. Oversimplified as this may seem, we shall find the idea more easily acceptable if we consider that bigness, or oversize, is really much more than just a social problem. It appears to be the one and only problem permeating all creation. Wherever something is wrong, something is too big.

He then builds an extensive argument that there are natural boundaries to growtha sentiment that was further elaborated on by The Limits of Growth some 15 years later, and is shared by many economists today. The solution, Kohr argues, is healthy decentralization. In respect to governance systems, that means a division into small states, resulting in a system where less power is divided into more hands, which could theoretically prevent atrocities like nuclear warfare and genocides that historically have been the hallmarks of large nations and empires.

Such dangers are still relevant today, and due to technological advances and the rise of global communication networks, the notion of threatening bigness has entered an entirely new domain. Today, a handful of tech giants control most of our communication, our personal data, what we see, what we hear, and where we go. Besides the Orwellian vibes, this concentration of power bears serious dependency risks. And with AI development being controlled and driven by the exact same data-oligarchs, wed better be careful all this rapid technological growth does not eventually backfire.

Just imagine if all Google services went down for a day. The implications would extend far beyond the inconvenience of using another search engine. Your browser data and passwords, your authentication apps, your calendars, everything you have stored in the cloudif all that disappeared, chaos would surely ensue in one form or another.

Yes, humanity would most likely recover from such disruptions, but it is crucial to recognize that we are currently in the early stages of a great technological transformation, comparable to the Industrial Revolution. AI is rapidly evolving, improving, and increasingly blurring the boundaries between whats real and whats not. The biggest stakeholders are the usual suspects: Google/Alphabet, Meta, Apple, and Microsoftwith OpenAI morphing into the unexpected lovechild of the latter two. As technology advances and markets become monopolized, further centralization and concentration of power are almost inevitable.

So, what can we do about this? Admittedly, from an individual standpoint, there are no simple solutions. While smaller alternatives to all the major services exist, convenience often outweighs the effort required to diversifybecause it is simply easier to use one account for everything, get all services from one provider, and store all files in the same cloud. However, spreading awareness about the dangers of centralization is essential. It enables individuals to balance convenience against the risks of over-dependency and make informed decisions. Ultimately, it is up to each of us to ensure we do not become overly reliant on any single platform, tool, or corporationand to prevent systems from becoming too big.

What are the primary qualities of Elementor that make it a popular choice for making WordPress sites without knowing how to code? You don’t have to know how to code to make a site with the help of Elementor for WordPress. You can introduce this module on your WordPress site. With Elementor, making a site is basically as simple as relocating components onto the homepage. This suggests that you can move things on your page, such as buttons, text boxes, and photographs, by tapping on them. Plus, Elementor comes with a tonne of pre-made templates. These templates offer pre-made designs that you may alter to suit your needs, giving you a head start. Colours, typefaces, and layouts can all be easily changed.

Even inexperienced clients can create proficient-looking sites because of its convenience. Whether you need to make an individual blog, a business site, or a web-based store, Elementor makes it simple and pleasant. Anyone, regardless of technical ability, may utilize Elementor to design a perfect site.

“Hostinger and Elementor: The Perfect Website Duo” for your website requirements. Hostinger provides quick and dependable hosting, whereas Elementor delivers user-friendly design tools. Together, they enable you to develop great websites quickly and efficiently. Start your online journey with Hostinger and Elementor today.

Designing with Elementor: Drag-and-Drop Basics

With Elementor, creating a website can be simple and enjoyable. One well-liked plugin for WordPress is Elementor. With a drag-and-drop interface, you can easily design stunning webpages. It follows that no prior coding knowledge is required. Installing Elementor on your WordPress website is the first step. After installation, you can immediately begin creating. To edit a page, just select it and launch Elementor on it. The user interface is easy to use. A panel with different elements, including text fields, photos, and buttons, is located on the left side. Any of these components can be dragged to the main window of your website. Simply click and drag an element to the desired location on the page to utilize it.

You may then personalize it by clicking on it. A menu will display, with options for changing the text, colour, size, and other settings. You can view all of your changes in real time, making design very intuitive. Elementor likewise provides pre-designed layouts. In the event that you’re new to website creation, these layouts are an amazing place to begin. You can choose a layout and then customize it to address your issues. Elementor permits you to make proficient-looking sites rapidly and without any problem. It’s an incredible instrument for both new users and specialists. Anybody can make a site utilizing its simplified elements without having any technical knowledge. This makes Elementor an excellent solution for small business owners, bloggers, and anyone looking to design their own website.

Advanced Design – Tips and Tricks in Elementor

Elementor’s Advanced Design Tips and Tricks can significantly improve the look and feel of your website. With the help of the well-known WordPress plugin Elementor, you can visually design websites without knowing any coding.

1. Learning how to apply custom CSS is one useful tip. Even though Elementor has a tonne of styling possibilities, there are situations when you might wish to create a unique look that isn’t possible with the default settings. Knowing the fundamentals of CSS will enable you to accurately alter elements to your preference.
2. Investigating sophisticated layout strategies is an additional helpful tip. You may construct intricate and responsive layouts with Elementor’s capabilities, which include adjustable column widths, configurable spacing, and widget positioning settings. Acquiring information on these components will empower you to deliver unique and more imaginative designs.

Best Practices for “Building” search engine optimization (SEO-Friendly) Sites with “Elementor”

Using Elementor to build SEO-friendly websites means adhering to a number of best practices that guarantee your website will appear highly in search engine results. To begin with, select a design that is both versatile and responsive. This suggests that your site ought to work and look perfect on a wide range of devices, including tablets and cell phones. Consider website speed next. Pages that load quickly are essential for SEO and the user experience. To speed up loading times, use a reputable hosting company, optimize your pictures, and employ cache plugins. Make keyword research a top priority while developing content. To locate appropriate terms with high search traffic, use tools such as Google Keyword Planner. Naturally include these keywords in your content’s titles, subheadings, and body.

Organize your information using clear headers and subheadings. This not only helps consumers navigate your site, but it also allows search engines to better grasp the structure of your material. Optimize your meta tags, including the title and meta description. These tags display in search engine results and should appropriately represent the content on each page, including important keywords. Make sure your website has a clear, crawlable structure. Use Elementor’s design features to construct a logical hierarchy complete with menus, breadcrumbs, and internal links. Regularly update your material to keep it current and relevant. Search engines prefer websites that consistently publish fresh information, so consider including blog entries, news updates, and other important content.

Finally, use tools like Google Analytics to track and evaluate the performance of your website. To track down regions that need work, watch out for investigations like keyword ranks, bounce rates, and traffic sources. You might utilize Elementor to make a site that looks fabulous and performs well in web search rankings, which will expand the amount of organic traffic to your site by sticking to these prescribed procedures. 

Elevate Your Online Presence – Discovering the “Benefits” of Robust WordPress (Server Hosting)

“Powerful WordPress server hosting” is required to run a successful website. It ensures that your site loads quickly and manages a large number of visitors efficiently. When you choose a strong hosting provider, such as one created particularly for WordPress, you will benefit from faster loading times, more consistent performance, and improved security measures. These hosting services frequently incorporate WordPress-specific features, such as one-click installations, automated updates, and specialized support from WordPress professionals. They employ high-performance servers that are optimized for WordPress, so your site can manage huge traffic without slowing down. Scalability is another benefit of high-performance WordPress hosting. As your website expands, you can simply change your hosting package to accommodate additional users and data.

Your website will always be quick and responsive because of its scalability, even as its popularity grows. Strong WordPress hosting places a high premium on security. In order to protect your website and its contents, providers frequently incorporate cutting-edge security features like virus scanning and automatic backups. You may relax knowing that your website is protected from online attacks due to this. Customer service is important to consider when selecting a hosting company. You usually have access to expert support staff when using powerful WordPress hosting, who can assist you with troubleshooting and performance optimization of your website. Therefore, for anyone who is serious about the functionality, speed, security, and scalability of their website, strong WordPress server hosting is a great option.

It’s designed to make administering a WordPress site simpler and more efficient, allowing you to concentrate on creating amazing content and expanding your online presence.

Conclusion

Elementor provides a complete toolkit for design, functionality, and SEO, enabling WordPress users to easily develop websites of a professional calibre. Elementor is the preferred option for web construction without coding because of its extensive features and user-friendly interface, regardless of the type of website you’re creating a personal blog, an E-commerce site, or a business page. Accept Elementor to open up countless opportunities and effortlessly improve your internet visibility.

Beyond just design, Elementor has strong features that increase usefulness without getting complicated, like widgets and integrations with well-known plugins. Because of its adaptability, users may easily add sophisticated components like galleries, forms, and sliders, improving both utility and appearance. Another noteworthy aspect of Elementor is its dedication to efficiency, with clean code and quick loading times both essential for good SEO. Elementor helps websites rank higher in search engine results by focusing on the user experience and speed, which efficiently drives organic traffic.

FAQs

Can I export/import Elementor designs?

Yes, Elementor allows you to export and import templates, sections, and even full websites, making it simple to reuse designs or migrate sites.

Does Elementor provide support and updates?

Yes, Elementor releases regular updates with bug fixes and new features, and they offer help through their documentation and community forums.

Is my website slowed down by Elementor?

Although Elementor is performance-optimized by design, utilizing an excessive number of large widgets or animations might slow down a website.

Can I use Elementor to make responsive websites?

Yes, Elementor makes it simple to create responsive websites that work well across all platforms.

With Elementor, what kinds of websites can I create?

With Elementor, you can make almost any sort of site, including blogs, internet business retail stores, portfolios, organization sites, and more.

Is there a template option in Elementor?

Yes, you may import and modify a library of pre-made templates for pages, sections, and entire websites that come with Elementor.

The post Elementor for WordPress: Build a Website with Ease (No Coding Required) appeared first on CSS Author.