Go Back to the Full Course: Next Level Prompt Engineering with AutoGen Studio

AutoGen Studio is an open-source interface that runs on top of AutoGen. This combination will allow us to work with LLMs and give them skills (like tools/functions) that they can use and also allows us to use agents and even define multi-agent workflows. Think of it as a multi-agent framework. One of the most amazing features is that it can write and execute code on the fly to solve problems!

On top of that AutoGen Studio provides us with a sleek and easy-to-use interface to define all the above and chat with our agents, much of it without even having to write code! This truly is next-level prompt engineering and over the coming lessons, we will harness the power of digital agents and see them collaborate with each other!

In this first part, we’ll focus on the setup and take some time to properly get started. If you’re a more seasoned developer and intimately familiar with a particular topic like Docker, feel free to skip ahead a bit here and there, but we’ll cover all the bases so that everybody can follow along nicely. This is especially so as much of AutoGen Studio can be used via the interface which makes it more accessible to non-coders. We will leave no man or woman behind!

AutoGen safety measures

In order to answer more complex requests AutoGen will actually write Python code for you and execute this Python code on your local computer.

For example, there is a demo question where you ask the following question: "Plot a chart of NVDA and TESLA stock price for 2023. Save the result to a file named nvda_tesla.png". AutoGen will solve this question by writing Python code to get the stock prices, install needed libraries to execute the code, write code for creating the graph in MathPlotLib, etc… It will then execute this code on your local computer and return the result to you.

The problem occurs where operating systems of course have some kind of built-in security. Generally, the Execution Policy on your OS will prevent AutoGen (and others) from just running random code and scripts on your computer. And this is a good thing! One solution would be to loosen up the Execution Policy on your computer, but this is not really the best idea. Even if you don’t have an Execution Policy problem on your system, do you really want to have any and all AI-generated code running on your machine without any checks or balances? It’s a bit dangerous, to say the least.

Why we won’t use Anaconda

Many tutorials try to take the 100% no-code approach, using Anaconda for virtual environments and not using an IDE like VS Code altogether in an attempt to claim that ‘You don’t need to know any code at all’. Then you will:

• Still have to install Docker as well as Anaconda, in order to allow safe code execution inside of a Docker container.
• Set your API key over and over every time you reload.
• Type the same Anaconda commands over and over.
• You might be stuck with a buggy experience trying to get it to use Docker for safe code execution, causing you a lot of frustration.

While there is absolutely nothing wrong with Anaconda, it doesn’t remove the need for Docker for safe code execution as it doesn’t provide any isolation from your local system. So why don’t we just use Docker instead of Anaconda AND Docker? This biting the bullet will make this part 1 of the tutorial a bit harder, but after that, it will be smooth sailing all the way!

Docker to the rescue

Using this approach we can skip Anaconda altogether as Docker will also be separate from our system-wide Python environment, and we have only 1 piece of software to worry about for both the separate environment and the safe code execution. We will use some bare basic code in the form of a ‘docker file’ and basic commands, but you can just copy mine, so no worries! Again, if you’re already a Docker expert, feel free to just skip ahead to the Dockerfile and get started.

Docker uses operating system-level virtualization to deliver software in packages called containers. Containers are isolated from one another and bundle their own software, libraries, and configuration files. All containers are run by a single operating system kernel and are thus more lightweight than virtual machines. Crudely stated this means that docker will let us have a separate container with Linux, Python, and all the libraries we need to run AutoGen Studio in it, kind of like running a different computer system within a virtual machine.

We will use this ‘virtual machine’, or Docker container, to run AutoGen Studio inside of it, which automatically also means that any code it generates is executed within the container, solving our code execution policy problems and safety concerns in one go. Caveat: Theoretically even Docker is not 100% secure and isolated from the rest of your system, but it’s a lot better than just running code directly on your local machine and good enough for non-enterprise use.

Getting Docker installed and running – WSL2

I’m going to assume you’re on a Windows machine. If you’re on a Mac or Linux machine, you’re in luck and can probably just run the installer for ‘Docker Desktop’ and be done with it. Just head over here and scroll down to select the Docker download for your platform. https://docs.docker.com/desktop/ (or Google for the updated link).

Continuing for the Windows users now, as they have a couple of extra steps to take. Most tutorials will just tell you to install Docker and give no details which might leave you will a hard and long process of figuring out why it won’t work on your system. So let’s cover the pitfalls and make sure we get it right the first time!

First, we need to install WSL2 (Windows Subsystem for Linux 2) on our system. This is a Windows feature that allows us to run Linux on our Windows machine. This is needed because Docker Desktop for Windows requires WSL2 to run. (You can also use Hyper-Vinstead, but WSL2 is the recommended way).

(If you already use WSL but need to check if you have version 2, you can check your version by entering the command: wsl -l -v in PowerShell or Windows Command Prompt.)

You can find the details for installing WSL2 here, but basically you do this:

• Open a PowerShell or Windows Command Prompt in administrator mode by right-clicking and selecting “Run as administrator”
• Run the following command in the terminal: wsl --install
• Restart your computer when prompted

This will enable WSL on your Windows machine and install a Linux distribution (Ubuntu) on your system. You may need to create a Username and Password for your Linux distribution and save them somewhere. More details can be found here or google "Setting up your Linux username and password."

Some things to check before we install Docker Desktop

A quick caveat: If anywhere along the way you run into problems I haven’t covered here, you’ll need to do some googling to find out what it means and what needs to be done, as I cannot prepare you for every possible problem you might run into.

The software development world sometimes requires messing around and googling for an hour or even two before you get something to work, it’s part of the game. That being said I will try my best to cover all bases so you’ll hopefully have a very smooth experience .

We have a couple more things to check before we can install Docker Desktop. First, we need to make sure the Virtual Machine Platform option is enabled. This is fairly easy! Just press the Windows key or click in the Windows search bar and search for “Turn Windows features on or off”.

Open this and make sure the “Virtual Machine Platform” option is checked. If it’s not, check it and click OK. You may need to restart your computer after this.

(You don’t have to match the other checkboxes with the settings in the image!)

Next, we need to make sure that Virtualization is enabled in our BIOS. The easiest way to check if this is enabled is to open the Windows Task Manager by pressing Ctrl+Alt+Delete and selecting Task Manager. Then click on the Performance tab and click on CPU on the left-hand side. If Virtualization is enabled, you will see “Virtualization: Enabled” in the bottom right information block like this:

If Virtualization is not enabled, you will have to go into your BIOS settings and enable Virtualization. This is where you will have to do some googling and research on your own, as every system has slightly different keys to get into the BIOS setup menu, and the settings may be located in different parts of the BIOS menu for different manufacturers. I’ll leave you with two links to get you started, the first one describes the general process of getting this setting enabled in your BIOS:

• Virtual Metric – How to enable hardware virtualization
• Docker Docs – Troubleshoot topics – virtualization

When you’ve got that ready and set up to go, let’s continue on.

Installing Docker Desktop

Finally, it’s time! Head over to the Docker Desktop download page here and download the appropriate Docker version for your OS. I’m running Docker 4.26.1, but just download the latest version and you should be fine. When the download finishes start the installer. The installer will give you the following options:

Just accept both of these options and click OK, unless you chose not to install WSL 2 and use Hyper-V instead. Whether or not you want a shortcut on your desktop is entirely up to you of course .

Now just let the installer do its magic:

Done!

Then go ahead and run the Docker Desktop application, where you’ll have to accept the service agreement:

And then just choose “Use recommended settings” and click Finish:

Now Docker Desktop will start and you will be prompted to either sign up or sign in. Docker is free for personal and even small-business use, so press the button to sign up and create an account. You can even use your Google or GitHub account to create one really fast. (You can also continue without signing in if you want to, and it should still work fine). I’m just going to go ahead and sign in with my Google account.

If everything was successful, you should be greeted by the following screen:

Congratulations! You’ve now installed Docker Desktop and are ready to go! If you still have problems, first try the below, and if that doesn’t work, google will have a solution. Never despair!

(Only for those who still have problems )

- Hypervisor enabled at Windows startup -
If you have completed the steps described above and are still experiencing Docker Desktop startup issues, this could be because the Hypervisor is installed, but not launched during Windows startup. Some tools (such as older versions of Virtual Box) and video game installers turn off hypervisor on boot. To turn it back on:

    - Open an administrative console prompt.
    - Run bcdedit /set hypervisorlaunchtype auto.
    - Restart Windows.

Creating a Dockerfile

Ok, now that we all have Docker Desktop installed and running, let’s move on to the next step! I’ll be using VS Code for this, just because it feels convenient to me. You can also use any other code editor or literally just copy the text into Notepad and use a separate terminal window, it makes no difference.

Create a base project directory and open it in VS Code. I’ll simply call my directory AUTOGEN:

AUTOGEN (root project folder)

Now inside the AUTOGEN folder create a new file called Dockerfile.base:

    AUTOGEN (root project folder)
        Dockerfile.base

What is a Dockerfile? A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image and ultimately run a Docker container. Think of this dockerfile as a recipe that Docker will follow to build a custom image that can be used to create new containers.

In a Dockerfile, you can specify the base image to use, define the working directory, copy files from your local system to the container, run commands to install packages, expose ports for the application, and specify the command that should be run when a container is launched from the image.

So open up your Dockerfile.base, and let’s type out our Docker recipe! This will be mostly based on the example recommendations from AutoGen itself, with some minor tweaks. First, let’s specify the base image:

FROM python:3.11-slim-bookworm

This will use the official Python image from Docker Hub, which is based on Debian Linux. We’ll use the slim-bookworm version, which is a lightweight version of Debian Linux. We’ll also use Python 3.11, which is in the range of current recommended versions for AutoGen at the time of writing.

Then continue in your Dockerfile.base with the following:

RUN apt-get update \
    && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
        software-properties-common sudo\
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

I’m going to explain what all the Docker commands do as these topics are interesting and very helpful as a developer, but if you’re not interested in Dockerfiles and Linux commands and don’t want to do any coding stuff, you have my blessings to skip the explanations and just scroll down to the finished Dockerfile at the end of this section and copy it into your own Dockerfile.base .

• RUN is a Dockerfile command that executes a command in the container. In this case, we’re running the apt-get update command, which refreshes the local package index with the latest versions. && is a command separator, which lets us chain commands.
• DEBIAN_FRONTEND=noninteractive is an environment variable that is set to noninteractive to prevent the apt-get install command from asking any questions during the installation and just apply default settings.
• apt-get install is the command to install packages. The -y flag is used to automatically answer yes to any questions that may come up during the installation process. The --no-install-recommends flag is used to prevent the installation of any recommended packages that are not strictly required for the package to function, keeping it light.
• software-properties-common is a package that provides utilities for managing software repositories. and sudo is a utility that allows us to run commands as a superuser.
• apt-get clean is a command that cleans up the local repository of retrieved package files, and rm -rf /var/lib/apt/lists/* is a command that removes the package lists that were downloaded during the apt-get update command. This is done to save disk space.

Next in our Dockerfile, we’ll set up a root user with superuser access:

RUN adduser --disabled-password --gecos '' autogen
RUN adduser autogen sudo
RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
USER autogen
WORKDIR /home/autogen

The first line creates a new user named autogen without a password and without prompting for additional information, whereas --gecos '' simply sets the user info to an empty string. The next line adds the user autogen to the sudo group, granting it administrative privileges.

The third line configures the sudo group to allow members to execute commands as root without requiring a password. After that, we switch to the autogen user and set the working directory to /home/autogen.

Next up:

ENV PATH="/home/autogen/.local/bin:$PATH"
ENV OPENAI_API_KEY=paste_your_api_key_here

First, we set the PATH environment variable (using Docker’s ENV command) to include the .local/bin directory in the autogen user’s home directory.

Then we set the OPENAI_API_KEY environment variable to the API key that we got from OpenAI. This is needed so that AutoGen Studio can access the OpenAI API.

Make sure you paste your own ChatGPT API key in there instead of paste_your_api_key_here, making sure not to add "" double quotes or anything. You create new or extra keys by going to the OpenAI API keys page:

Ok now to continue in our Dockerfile:

RUN pip install pyautogen==0.2.8 autogenstudio==0.0.34a0 numpy pandas matplotlib seaborn scikit-learn requests urllib3 nltk pillow pytest beautifulsoup4

We just pre-install some of the popular packages and of course pyautogen and autogenstudio themselves. I have specified two specific versions for pyautogen and autogenstudio, as these are the versions I’m using when writing this tutorial. I advise you to use the same ones to make sure you have exactly the same experience as me. You can always upgrade the packages after you finish the tutorial series. (Don’t worry, at the end of the last part I’ll show you how and you won’t lose any of your work!)

Now next up in our Dockerfile:

# Expose port
EXPOSE 8081

# Start Command for AutoGen Studio
CMD ["autogenstudio", "ui", "--host", "0.0.0.0", "--port", "8081"]

The EXPOSE command exposes port 8081, which is the port that AutoGen Studio will run on. The CMD command specifies the command that will be run when the container is launched from the image. In this case, we’re running the autogenstudio command with the ui option, which will start the AutoGen Studio interface. The --host and --port options specify the host and port that the interface will be available on. This means we’ll only have to start the container and AutoGen Studio will be available on port 8081 automatically!

Note that we used the address 0.0.0.0 instead of the usual localhost 127.0.0.1. If we bind to the 127.. version it’s only accessible from the same machine – in this case, the same Docker container. To make our application accessible from outside the Docker container, you need to bind it to 0.0.0.0 instead. This will make it accessible from any IP address, including from your host machine.

To finish off our Dockerfile, we’ll add a comment at the bottom for our own future reference:

# command to build the image:
    # docker build -t autogenstudio -f Dockerfile.base .
# command to run the container:
    # docker run -it --rm -p 8081:8081 --name autogenstudio autogenstudio
# Access AutoGen Studio at http://localhost:8081 make sure you don't click the 0.0.0.0:8081 link in the terminal, it won't work!

This is just a comment that you can use for future reference so you don’t have to search the tutorial to find the command to build and run the container, we’ll use and explain these commands in a second, just copy them for your future reference.

Building the Docker image and running the container

Your whole Dockerfile.base should now look like this:

FROM python:3.11-slim-bookworm

RUN apt-get update \
    && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
        software-properties-common sudo\
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Setup a non-root user 'autogen' with sudo access
RUN adduser --disabled-password --gecos '' autogen
RUN adduser autogen sudo
RUN echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
USER autogen
WORKDIR /home/autogen

# Set environment variable
ENV PATH="/home/autogen/.local/bin:$PATH"
# Follow the = with your OpenAI API key (no quotes or anything, just OPENAI_API_KEY=sk-lotsOfLettersAndNumbers)
ENV OPENAI_API_KEY=

# Pre-load popular packages
RUN pip install pyautogen==0.2.8 autogenstudio==0.0.34a0 numpy pandas matplotlib seaborn scikit-learn requests urllib3 nltk pillow pytest beautifulsoup4

# Expose port
EXPOSE 8081

# Start Command for AutoGen Studio
CMD ["autogenstudio", "ui", "--host", "0.0.0.0", "--port", "8081"]

# command to build the image:
    # docker build -t autogenstudio -f Dockerfile.base .
# command to run the container:
    # docker run -it --rm -p 8081:8081 --name autogenstudio autogenstudio
# Access AutoGen Studio at http://localhost:8081 make sure you don't click the 0.0.0.0:8081 link in the terminal, it won't work!

Ok, so with that out of the way, first make sure that the Docker Desktop application is running, as we’ll need the Docker Engine process to be up and running. Then open up a terminal window and make sure you’re in the root project folder, in my case AUTOGEN:

admin@DirkMasterPC /c/Coding_Vault/AUTOGEN

Then run the following command to build the image:

docker build -t autogenstudio -f Dockerfile.base .

This will build the image and tag (-t) it with the name autogenstudio. The -f flag specifies the name of the Dockerfile to use, in this case Dockerfile.base. The . at the end specifies the build context, which is the current directory, as this is where our Dockerfile.base is located.

The Docker Image will be built and you will see the progress running through each of the steps in the Dockerfile. When it is done we can run the following command to start the container which will automatically run AutoGen Studio:

docker run -it --rm -p 8081:8081 --name autogenstudio autogenstudio

This works by running the docker run command, which creates a new container from the autogenstudio image that we just built. The -it flag specifies that we want to run the container in interactive mode, which means we can interact with the container via the terminal.

The --rm flag specifies that we want the container to be removed when it is stopped. The -p flag specifies that we want to map port 8081 from the container to port 8081 on our local machine. The --name flag specifies the name of the container, in this case, autogenstudio.

Now bring up your Docker Desktop application and open up the Containers tab (topmost icon in the left menu bar):

We can see that our container by the name autogenstudio, based on the image autogenstudio is running on port 8081! Hooray!

Victory!

You can either click on the blue 8081:8081 link to open up AutoGen Studio in your browser, or just open up your browser and go to http://localhost:8081. There is also a link in your terminal window that says that Uvicorn is running on http://0.0.0.0:8081. Do not click this link as the 0.0.0.0:8081 address is only accessible from within the Docker container and you are outside of it, so it will not work.

Give yourself a pat on the back for a job well done! You’ve set up AutoGen Studio properly and inside a Docker container! One quick sidenote, when we wrote the Dockerfile.base we hardcoded the ChatGPT API key into the Dockerfile to keep things as simple as possible. We can of course avoid this but this would complicate the tutorial further and I want to keep this one as low-code as possible.

Just make sure you do not share the Dockerfile.base or remove your API key from it first as anyone with your API key can obviously use OpenAI’s API on your credit. Your Docker Image also has the API key hardcoded into it. There is no reason you’d ever really want to share the image though, just don’t leave copies behind on a public computer or something.

That’s it for part 1! I hope it wasn’t too difficult. From now on the fun part begins. I’ll see you in part 2 where we’ll dive straight into AutoGen Studio.

Go Back to the Full Course: Next Level Prompt Engineering with AutoGen Studio

The post How to Set Up AutoGen Studio with Docker appeared first on Be on the Right Side of Change.

The search_google(query, num_results) function performs a search using the Google Custom Search JSON API, with the search query and the desired number of results (num_results) as parameters.

Upon a successful API request (HTTP Status Code 200), the function extracts and prints titles, URLs, and snippets of the search results.

Subsequently, it employs the get_texts_from_urls function to retrieve the text content from each URL, which internally uses get_text_from_url to send a GET request to each URL, parse the HTML using BeautifulSoup, and extract the text. The extracted texts are then printed along with their respective lengths.

The API key (google_search_api) and Custom Search Engine ID (google_search_cx) are needed to authenticate and specify the search engine, respectively. Both are free though.

Note: The API key and Custom Search Engine ID should be obtained from Google Cloud Console and Programmable Search Engine, respectively, and should be kept confidential to prevent unauthorized usage. Both are free for up to 100 requests per hour or so.

Otherwise, you can just copy and paste the following code into your Jupyter notebook (or Google Colab):

import requests
from bs4 import BeautifulSoup


keyword = 'get stock price in excel cell'
google_search_api = '...' # https://developers.google.com/custom-search/v1/introduction
google_search_cx = '...' # https://programmablesearchengine.google.com/controlpanel/create


def search_google(query, num_results=10):
    '''Returns a list of strings with the text of the first n google results'''

    # Google Custom Search JSON API URL
    api_url = "https://www.googleapis.com/customsearch/v1"
    
    # Parameters for the API request
    params = {
        'key': google_search_api,  # Your API key
        'cx': google_search_cx,  # Your Custom Search Engine ID
        'q': query,  # The search query
        'num': num_results  # The number of results to retrieve
    }
    
    # Make the API request
    response = requests.get(api_url, params=params)
    
    # Check if the request was successful (HTTP Status Code 200)
    if response.status_code == 200:
        # Parse the JSON response
        results = response.json()
        
        titles = [item['title'] for index, item in enumerate(results.get('items', []))]
        print(titles)

        urls = [item['link'] for index, item in enumerate(results.get('items', []))]
        print(urls)

        snippets = [item['snippet'] for index, item in enumerate(results.get('items', []))]
        print(snippets)

        # Get the Text of all URLs
        texts = get_texts_from_urls(urls)
        print(texts)

        for text in texts:
            print(len(text))

        

    else:
        print("Failed to retrieve results:", response.status_code, response.text)


def get_text_from_url(url):
    try:
        # Send a GET request to the URL
        response = requests.get(url)
        
        # Check if the request was successful (HTTP Status Code 200)
        if response.status_code == 200:
            # Parse the HTML content of the page with BeautifulSoup
            soup = BeautifulSoup(response.text, 'html.parser')
            
            # Extract text from the parsed HTML
            return soup.get_text(separator="\n", strip=True)
        else:
            print(f"Failed to retrieve content from {url}. Status code: {response.status_code}")
            return None
    except Exception as e:
        print(f"An error occurred while fetching {url}: {str(e)}")
        return None


def get_texts_from_urls(urls):
    texts = []
    for url in urls:
        text = get_text_from_url(url)
        if text:
            texts.append(text)
    return texts



search_google(keyword, 5)

If you don’t use Google Colab Notebook to run the code (e.g., in your own .py script), you may need to install BeautifulSoup and Requests — check out the linked articles for a quick tutorial on accomplishing this.

For the provided keyword 'get stock price in excel cell', the output of this code was as follows:

['Get a stock quote - Microsoft Support', 'The formula that returns real-time stock prices', 'Excel data types: Stocks and geography - Microsoft Support', 'Add Real-Time Stock Prices And Metrics To Excel', 'Get stock price (latest close) - Excel formula | Exceljet']
['https://support.microsoft.com/en-us/office/get-a-stock-quote-e5af3212-e024-4d4c-bea0-623cf07fbc54', 'https://www.morningbrew.com/money-scoop/stories/2021/08/24/formula-returns-realtime-stock-prices', 'https://support.microsoft.com/en-us/office/excel-data-types-stocks-and-geography-61a33056-9935-484f-8ac8-f1a89e210877', 'https://www.thespreadsheetguru.com/add-real-time-stock-prices-and-metrics-to-excel/', 'https://exceljet.net/formulas/get-stock-price-latest-close']
["Type some text in cells. · Then select the cells. · Although it's not required, we recommend creating an Excel table. · With the cells still selected, go to the\xa0...", 'Aug 24, 2021 ... In Excel: Yep, Excel can return stock prices, too. Enter each ticker in its own cell > Highlight the cells > Select “Data” > “Stocks” > Tap\xa0...', '... price are getting extracted from the Geography data type in column A. Type some text in cells. If you want stock information, type a ticker symbol, company\xa0...', 'Jul 28, 2019 ... If you click the Convert to 

...

problem with this page\nHelp us improve Exceljet\nYou must have JavaScript enabled to use this form.\nName\nEmail\nProblem\n*\nYour email address is private and not shared.\nExceljet\nQuick, clean, and to the point\nResources\nTraining\nVideos\nFunctions\nFormulas\nShortcuts\nArticles\nAbout Us\nAbout\nTestimonials\nTopics\nContact\nNewsletter Sign-up\nWork faster in Excel.\nJoin more than 100,000\npeople who get weekly tips from us.\nEmail\nHP\n© 2012-2023 Exceljet.\nTerms of use\nVisit our Twitter page']
6189
9885
8960

Thanks for reading the article and feel free to join our 100% free email academy by downloading our Python cheat sheets:

The post Get First N Google Search Results in Python (Official Way) appeared first on Be on the Right Side of Change.

Step 1: Set up Google Sheets API

• Go to the Google Developers Console.
• Create a new project.
• Enable the Google Sheets API for the project.
• Create service account credentials.
• Download the JSON key for these credentials.
• Share your Google Sheet with the email address associated with the service account (you can find this in the JSON key).

Step 2: Install GSpread Library and Authentication

Run the following in your environment (e.g., Windows, Linux, macOS terminal/console/shell):

pip install gspread oauth2client

1. gspread: A Python library that provides a simple interface to interact with Google Sheets, allowing for reading, writing, and modifying spreadsheet data.
2. oauth2client: A library for OAuth 2.0 client-side authentication, which is commonly used to grant access to Google APIs.

Note: For newer projects, you might want to consider using the google-auth and google-auth-oauthlib libraries instead.

Step 3: Python Script

The following script is designed to add data to a Google Sheet using Python.

It first sets up the necessary tools and permissions by importing specific libraries and defining the scope of access it requires, such as reading and writing to Google Sheets and accessing Google Drive.

The script then authenticates itself using a service account’s credentials, which are loaded from a provided JSON file. Once authenticated, it accesses a specified Google Sheet and its first tab.

The script then defines a sample set of data, which it subsequently appends to the bottom of the accessed sheet. After successfully adding the data, the script confirms the action by displaying a success message.

import gspread
from oauth2client.service_account import ServiceAccountCredentials

# Set up the credentials
scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/spreadsheets", "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive"]
creds = ServiceAccountCredentials.from_json_keyfile_name('path_to_service_account_key.json', scope)
client = gspread.authorize(creds)

# Open the Google Sheet using its name
sheet = client.open("Your Google Sheet Name").sheet1

# Data to append
data = ["John", "Doe", 25]

# Append the data
sheet.append_row(data)

print("Data appended successfully!")

Replace 'path_to_service_account_key.json' with the path to your downloaded JSON key and "Your Google Sheet Name" with the name of your Google Sheet.

Step 4: Run the script

Execute the Python script. It will append the data to the Google Sheet.

Recommended: How to Run a Python Script?

Remember, every time you want to append new data, you can modify the data list in the script and run it again.

The post How to Append Data in a Google Sheet with Python appeared first on Be on the Right Side of Change.

You can activate the code interpreter in your ChatGPT Settings:

Toggle the “Code Interpreter” option (currently in “Beta features” but not for long):

Now you can run the code interpreter using a simple natural language prompt such as "Create a histogram of points drawn from a random distribution in Python and visualize the result".

Here’s an example run in my ChatGPT environment:

Yay you can now run Python code and plot scripts in your ChatGPT environment!

If you click on the “Show work” button above, it toggles the code that was executed:

A simple feature but powerful — using ChatGPT has now become even more convincing for coders like you and me.

Also make sure to check out our prompting tricks:

Recommended: Best 35 Helpful ChatGPT Prompts for Coders (2023)

The post GPT-4 Code Interpreter – How to Run Python & Plot Data in ChatGPT appeared first on Be on the Right Side of Change.

Here’s a small list of ideas you can use the Cognosys autonomous agent for:

1. Content Ideas: Generate trending health & wellness topics.
2. Product Comparison: Compare top smartphones.
3. Blog Post Research: Get facts & stats for remote work posts.
4. SEO Research: Discover keywords for a Europe travel blog.
5. Influencer Search: Locate fashion influencers on Instagram.
6. Social Media Planner: Create a content calendar for travel agencies.
7. News Analysis: Break down specific news articles.
8. AI News Digest: Craft an AI-focused newsletter.
9. News Summary: Summarize news on a specific topic.
10. Industry News: Develop a news roundup for a chosen industry.

Here’s an example run I did:

By exploring the potential of Cognosys.ai, you can stay ahead of the curve in an ever-changing technological landscape and leverage AI technology efficiently. Its user-oriented approach and cutting-edge features make it an essential tool for people looking to integrate AI into their daily routines.

Overview of Cognosys.AI

Cognosys.AI is a powerful web-based AI agent designed to revolutionize productivity and simplify complex tasks for you. As your friendly AI assistant, Cognosys aims to elevate your everyday life with the most advanced AI technology available.

It’s built on proprietary software. The innovative code base behind the AI agent is inspired by recent developments in artificial intelligence and machine learning. This allows Cognosys to constantly adapt and improve, offering you a fresh, cutting-edge user experience.

It reminded me of Auto-GPT but it’s far more accessible, maybe more like Godmode.space (but even better).

Recommended: Setting Up Auto-GPT Any Other Way is Dangerous!

With Cognosys.AI, you’ll discover a range of features designed to support you in both your professional and personal lives. The agent is currently in beta, but it is continuously being updated with new functionalities to help you unlock the full potential of AI-driven applications.

One exciting update from Cognosys.AI is their Coding Mode Beta, which provides you with a whole new way of interacting with the AI agent. It allows you to write and execute code directly within Cognosys, making it possible for you to build intelligent, efficient, and effective applications without having to leave the platform.

You can also use different LLMs such as GPT3.5, GPT4 (pro only!), Claude+, Cohere, PaLM2 by clicking the ⚙ Settings button:

It also provides a number of templates, simply click the 💡 Discover button on the left side pane:

Awesome! I particularly loved the creative templates such as “Financial Statement Analysis” — imagine the disruptive power of tools like these potentially replacing (or enriching) the work of millions of highly paid financial analysts.

What services does cognosys.ai offer?

Cognosys.ai offers a revolutionary web-based AI agent designed to simplify complex tasks and improve productivity. The AI agent can assist in areas like news aggregation, trend monitoring, and data collection.

I extracted this list from the offered templates — but this is only the beginning!

1. Content Ideas Generator: Find trending topics and keywords in health and wellness for blog content ideas.
2. Product Comparison: Research and compare top smartphones.
3. Blog Post Research: Find statistics, facts, and expert quotes for a remote work blog post.
4. SEO Keyword Research: Keyword research for a blog post about the best places to visit in Europe.
5. SEO Optimized Blog Writing: Keyword research for a blog post about the best places to visit in Europe.
6. Influencer Research: Find Instagram influencers in the fashion industry.
7. Social Media Content Calendar: Create a social media content calendar for a travel agency.
8. News Article Analysis: Analyze a specific news article and extract key information.
9. AI News Digest: Create a newsletter about the latest AI news.
10. Topic-Specific News Summary: Summarize the latest news about a specific topic.
11. Industry News Roundup: Create a news roundup for a specific industry.
12. Weekly News Update: Create a weekly news update for a specific subject.
13. Financial Statement Analysis: Financial ratio analysis of the uploaded financial statements.
14. Website Analysis: Analyze the content and structure of example.com.
15. Legal Document Summary: Summarize the uploaded legal contract.
16. Patent Analysis: Analyze the uploaded patent document.
17. Event Planning: Find and compare event venues in New York City.
18. Product Launch Plan: Develop a plan for launching a new product.
19. Research Paper Summarization: Summarize the uploaded research paper.
20. Grant Proposal Writing: Write a grant proposal for an environmental conservation project.
21. Personal Statement: Write a college application personal statement.
22. Product Description: Create a product description for organic skincare products.
23. Executive Summary: Write an executive summary for a business report.
24. Case Study: Write a case study about a successful customer experience.
25. Recipe Ideas: Find healthy, plant-based dinner recipes.
26. Job Market Analysis: Analyze the job market for software engineers.
27. Resume Evaluation: Evaluate and provide feedback on the uploaded resume.
28. Django Web App: Develop a Django web app for an online store.
29. WordPress Plugin: Create a custom WordPress plugin for social sharing buttons.
30. Mobile App UI: Create a mobile app UI for a water intake tracker.
31. Chatbot Integration: Implement a chatbot for customer support on a website.
32. Angular Web App: Develop an Angular web app for project management.
33. Ruby on Rails API: Create a Ruby on Rails backend API for a blog platform.
34. Educational Resources: Discover online resources for learning data science.
35. Sales Pitch: Create a sales pitch for eco-friendly cleaning products.

What industries does cognosys.ai cater to?

Cognosys.ai caters to a wide range of industries, as their AI agent can assist in various tasks. From news aggregation to trend monitoring and data collection, businesses in diverse sectors can benefit from their services. See the list before.

How can I get started with cognosys.ai?

To get started with cognosys.ai, visit their website and sign up for an account. From there, you will be able to access their AI agent and explore its services.

How does cognosys.ai utilize AI technology?

Cognosys.ai utilizes AI technology by creating an innovative AI agent which serves as your personal assistant for accomplishing various tasks. They use proprietary software, and their AI agent is built on models like GPT-3.5.

Are there any success stories involving cognosys.ai?

Cognosys.ai is still in beta, so success stories may not be widely available. However, the potential of their AI technology is evident in the positive reviews and user experiences shared on their website.

What Is Cognosys.ai?

CognosysAI is a web-based AI agent similar to Auto-GPT and BabyAGI that leverages large language models (LLMs) such as GPT-3.5 and GPT-4 to autonomously complete complex tasks that involve web search or other research. You can use it as a research assistant or virtual assistant.

Cognosys vs ChatGPT

Both are AI tools based on large language models. ChatGPT focuses on a human-dialogue interface, whereas Cognosys focuses on creating an autonomous agent that prompts an LLM such as GPT-3.5 not once but multiple times, essentially designing its own prompts. This way, you can give Cognosys more difficult and complex tasks than ChatGPT. Think of it as a meta-tool one layer above ChatGPT.

What Are Cognosys Agents and Loops?

Cognosys Agents are processes, i.e., autonomous helpers that work on the objective you give them when starting the Cognosys tool. One call of the Cognosys tool may trigger multiple agents to work together on a common goal.

Cognosys Loops are series of tasks. If you start an agent with a specific goal, it generates a number of tasks. The series of tasks towards an objective is called a loop. As each loop completes, the agent determines whether the overall objective has been completed, or not.

Is Cognosys Free?

Cognosys.ai offers a Free plan as a generous introduction to building your own AI assistants. The free tier has 10 credits, i.e., 10 tasks. They also provide additional plans with higher limits, more advanced models, and other features to help you take your AI agent to the next level.

To keep learning about the fascinating world of LLMs and exponential technologies, check out my free email academy (>100k subs) and read the following blog post:

Recommended: Top 7 Ways to Use Auto-GPT Tools in Your Browser

The post I Tried Cognosys.ai: Mind-Blown … Again 🤯 appeared first on Be on the Right Side of Change.

Online Substring Remover

Remove Substring
Output: Copy to Clipboard

The post Remove Substring From String (Easy Online Tool) appeared first on Be on the Right Side of Change.

Here is a basic outline of how you could accomplish this:

1. Enable the REST API in WordPress: WordPress has a REST API built in that you can use to interact with the site via Python. The REST API is enabled by default in WordPress 4.7 and later. You can check if it’s available by visiting http://your-site-url/wp-json/.
2. Authentication: To publish a post, you need to be authenticated. The most common way of doing this is through Basic Auth, which WordPress doesn’t support out of the box. You will need to install a plugin to enable it. There are multiple plugins available that provide this capability. One option is to use the Application Passwords plugin. After installation, generate a new application password for your user in the WordPress dashboard.
3. Use Python to Publish a Post: Once you’ve set up the API and the authentication, you can use the Python requests library to send HTTP requests to the WordPress server. Here is a basic example of how to publish a new post:

import requests
import json

# The URL for the API endpoint
url = 'http://your-site-url/wp-json/wp/v2/posts'

# Your WordPress username
username = 'your-username'

# The application password you generated
password = 'your-application-password'

# The post data
data = {
    'title': 'My New Post',
    'content': 'This is the content of my new post.',
    'status': 'publish'  # Use 'draft' to save the post as a draft
}

# Send the HTTP request
response = requests.post(url, auth=(username, password), json=data)

# Check the response
if response.status_code == 201:
    print('Post created successfully')
else:
    print('Failed to create post: ' + response.text)

Replace 'http://your-site-url', 'your-username', and 'your-application-password' with your WordPress site URL, your WordPress username, and the application password you generated.

Warning: Basic Auth sends the username and password in clear text with each request, so you should only use it over HTTPS in a production environment. For a more secure method, you should look into using a more secure authentication method such as OAuth (see below).

How Can You Format the Post Content (e.g., Background Color, Bold, Italic, …)?

The WordPress REST API accepts content in HTML format. So you can add formatting to your content by using appropriate HTML tags.

For instance, to add an image you can use the <img> tag, and to create a blue background for a paragraph you can use the <p> tag with inline CSS. Here’s an example:

data = {
    'title': 'My New Post',
    'content': '''
    This is a paragraph with no special formatting.
    
    <p style="background-color: blue; color: white;">This is a paragraph with a blue background and white text.</p>
    
    <img src="http://your-site-url/path-to-your-image.jpg" alt="My Image">
    
    This is another paragraph with no special formatting.
    ''',
    'status': 'publish'
}

In the above example, replace 'http://your-site-url/path-to-your-image.jpg' with the actual URL of the image you want to insert.

For more advanced formatting, you might want to use a page builder that supports more advanced layouts and then view the resulting HTML to see how it’s done.

Note: If you want to upload a new image through the API and use it in a post, that would require a separate API request to first upload the image, and then you can use the returned URL to insert the image into your post. The process of uploading images via the WordPress REST API is somewhat more complicated and beyond the scope of this question. You may want to refer to the WordPress REST API documentation for more details.

A Few Words on Safe Authentication

The WordPress REST API supports OAuth authentication. To use OAuth, you first need to register an application in WordPress. The OAuth process is somewhat more complex than basic authentication, and it requires a plugin to enable it, such as the WordPress OAuth Server plugin.

Once you have registered your application and obtained your client ID and client secret, you can use a library like requests-oauthlib to perform the OAuth flow and make authenticated requests to the WordPress REST API.

Here’s a simplified example:

from requests_oauthlib import OAuth1Session

# Your WordPress site URL
site_url = 'http://your-site-url'

# Your client ID and client secret
client_id = 'your-client-id'
client_secret = 'your-client-secret'

# Get a request token
request_token_url = f'{site_url}/oauth1/request'
oauth = OAuth1Session(client_id, client_secret=client_secret)
fetch_response = oauth.fetch_request_token(request_token_url)
resource_owner_key = fetch_response.get('oauth_token')
resource_owner_secret = fetch_response.get('oauth_token_secret')

# Redirect the user to the authorization URL
base_authorization_url = f'{site_url}/oauth1/authorize'
authorization_url = oauth.authorization_url(base_authorization_url)
print('Please go to the following URL and authorize the app: ' + authorization_url)

# The user will be redirected to a callback URL with a verifier in the query string
verifier = input('Please input the oauth_verifier: ')

# Get an access token
access_token_url = f'{site_url}/oauth1/access'
oauth = OAuth1Session(client_id, client_secret=client_secret, resource_owner_key=resource_owner_key, resource_owner_secret=resource_owner_secret, verifier=verifier)
oauth_tokens = oauth.fetch_access_token(access_token_url)

# You can now use oauth to make requests to the API
url = f'{site_url}/wp-json/wp/v2/posts'
data = {
    'title': 'My New Post',
    'content': 'This is the content of my new post.',
    'status': 'publish'
}
response = oauth.post(url, json=data)

In this code, replace 'http://your-site-url', 'your-client-id', and 'your-client-secret' with your WordPress site URL, your client ID, and your client secret.

This code initiates the OAuth 1.0a three-legged flow.

• It first fetches a request token, then it prints an authorization URL for the user to visit and authorize the app.
• After the user has authorized the app, they will be redirected to a callback URL with an oauth_verifier in the query string. The user needs to copy this verifier and input it into the Python script.
• The script then fetches an access token and uses it to make authenticated requests to the API.

Please note that this is a simplified example and might not cover all cases. For a complete OAuth flow, you would need to implement a callback URL to automatically receive the verifier and complete the flow without manual intervention. Also, you should handle errors and edge cases appropriately in your production code.

Also, this code uses OAuth 1.0a, as it’s supported by the WordPress OAuth Server plugin. Some plugins or installations may support OAuth 2.0, which has a slightly different flow. Please refer to the documentation of your specific OAuth server for more information.

If you’re not familiar with OAuth, it’s a complex protocol, and it might be worthwhile to read up on it before implementing it in your application. There are many resources available online, including the official OAuth guide.

Do you want to keep learning and improving your Python skills? Check out our free cheat sheets here:

The post How to Publish a WordPress Post using Python? appeared first on Be on the Right Side of Change.

Tool #1 – Auto-GPT on Hugging Face

Hugging Face user aliabid94 created an Auto-GPT web interface (100% browser-based) where you can put in your OpenAI API key and try out Auto-GPT in seconds.

To get an OpenAI API key, check out this tutorial on the Finxter blog or visit your paid OpenAI account directly here.

The example shows the Auto-GPT run of an Entrepreneur-GPT that is designed to grow your Twitter account.

Tool #2 – AutoGPTJS.com

I haven’t tried autogptjs.com but the user interface looks really compelling and easy to use. Again, you need to enter your OpenAI API key and you should create a new one and revoke it after use. Who knows where the keys are really stored?

Well, this project looks trustworthy as it’s also available on GitHub.

Tool #3 – AgentGPT

AgentGPT is an easy-to-use browser based autonomous agent based on GPT-3.5 and GPT-4. It is similar to Auto-GPT but uses its own repository and code base.

I have written a detailed comparison between Auto-GPT and AgentGPT on the Finxter blog but the TLDR is that it’s easier to setup and use at the cost of being much more expensive and less suitable for long-running tasks.

Tool #4 – AutoGPT UI with Nuxt.js

AutoGPT UI, built with Nuxt.js, is a user-friendly web tool for managing AutoGPT workspaces. Users can easily upload AI settings and supporting files, adjust AutoGPT settings, and initiate the process via our intuitive GUI. It supports both individual and multi-user workspaces. Its workspace management interface enables easy file handling, allowing drag-and-drop features and seamless interaction with source or generated content.

Some More Comments…

Before you go, here are a few additional notes.

Token Usage and Revoking Keys

To access Auto-GPT, you need to use the OpenAI API key, which is essential for authenticating your requests. The token usage depends on the API calls you make for various tasks.

You should set a spending limit and revoke your API keys after putting them in any browser-based Auto-GPT tool. After all, you don’t know where your API keys will end up so I use a strict one-key-for-one-use policy and revoke all keys directly after use.

3 More Tools

The possibilities with Auto-GPT innovation are vast and ever-expanding.

For instance, researchers and developers are creating new AI tools such as Godmode (I think it’s based on BabyAGI) to easily deploy AI agents directly in the web browser.

With its potential to grow and adapt, Auto-GPT is poised to make an impact on numerous industries, driving further innovation and advancements in AI applications.

AutoGPT Chrome extension is another notable add-on, providing an easily accessible interface for users.

Yesterday I found a new tool called JARVIS (HuggingGPT), named after the J.A.R.V.I.S. artificial intelligence from Ironman, that is an Auto-GPT alternative created by Microsoft research that uses not only GPT-3.5 and GPT-4 but other LLMs as well and is able to generate multimedia output such as audio and images (DALL-E). Truly mindblowing times we’re living in.

Recommended: Auto-GPT vs Jarvis HuggingGPT: One Bot to Rule Them All

The post Top 7 Ways to Use Auto-GPT Tools in Your Browser appeared first on Be on the Right Side of Change.

Auto-GPT is an autonomous agent building on OpenAI’s large language model (LLM). Meanwhile, Jarvis, inspired by Iron Man’s ever-loyal virtual assistant, aims to bring a new level of AI-powered assistance to users.

Auto-GPT vs Jarvis: Overview

Both are powerful AI systems for various tasks and applications, making them essential tools for developers and researchers alike.

Auto-GPT

Auto-GPT is an experimental open-source project that aims to make the GPT-4 model fully autonomous. It serves as a showcase of the possibilities AI can achieve with minimal human intervention, potentially generating content and taking actions surpassing real-world business practices or legal requirements.

Recommended: Setting Up Auto-GPT Any Other Way is Dangerous!

Auto-GPT can be easily extended with custom tooling functionality and has a growing community of users. The project works well not only with GPT-3.5 but also with GPT-4, according to some users.

Jarvis

Jarvis is a project developed by Microsoft to connect Language Models with Machine Learning applications. It provides a robust system for developers to build and integrate AI-driven solutions with ease. Jarvis supports major AI services, such as the OpenAI platform and the GPT-4 model.

Image Credits: GitHub

The platform provides comprehensive documentation and resources for developers to get started, as well as a Gradio demo hosted on Hugging Face Space, allowing users to easily interact with the AI and explore its potential applications.

TLDR; Auto-GPT explores the full autonomy of AI models, while Jarvis provides a versatile platform for developers to create AI-driven applications with popular Language Models, such as GPT-4. Both projects are valuable resources for anyone looking to leverage the power of AI.

Sources see below.

Comparison of Key Features

Let’s compare the key features of Auto-GPT and Jarvis, two state-of-the-art AI technologies developed by OpenAI and Microsoft, respectively.

Language Models

Auto-GPT is an AI language model developed by OpenAI based on the GPT-3 architecture. It aims to generate high-quality natural language text. On the other hand, Jarvis is a unified AI bot created by Microsoft that brings together multiple language understanding models, such as ChatGPT, LLM, and GPT-4 (source).

Here’s an example screenshot of Jarvis, aka HuggingGPT, on Huggingface:

Performance

While specific performance metrics are not available for Auto-GPT, it leverages the advanced GPT architecture by OpenAI to generate impressive natural language outputs. Jarvis, as a unified platform, combines various models like ChatGPT to offer a seamless and highly efficient natural language understanding and generation experience.

Jarvis

Ease of Use

Auto-GPT can be accessed using an OpenAI API key, making it relatively easy to integrate into projects. Jarvis, being a part of Microsoft’s ecosystem, offers smooth integration with existing tools and services, providing a familiar environment for developers.

Personally, I found Jarvis on Huggingface is really easy to use compared to installing Auto-GPT with Dockers, which can be a pain.

Accessing Auto-GPT

With these key features in mind, Auto-GPT and Jarvis exhibit different strengths in terms of language models, performance, and ease of use.

Popular Use Cases

In this section, we’ll explore popular use cases for Auto-GPT and Jarvis, covering the following topics: Chatbots and AI Agents, Generative AI, and Machine Learning Classification.

Chatbots and AI Agents

Auto-GPT and Jarvis are both highly versatile and can be effectively utilized for creating chatbots and AI agents . Their natural language understanding capabilities make it possible for developers to craft conversational interfaces that are responsive and engaging. Powered by Hugging Face, Auto-GPT benefits from open-source resources, making it an accessible option for developers.

Generative AI

Auto-GPT, based on the GPT-3 architecture, excels in generating high-quality natural language content . It can be employed for various tasks, such as creating articles, poems, or stories, and drafting emails source. By leveraging Auto-GPT’s generative properties, developers can create unique content and automate text generation across various domains.

Machine Learning Classification

Both Auto-GPT and Jarvis can be effectively used for machine learning classification tasks . These AI-powered models can sift through vast amounts of data and recognize patterns, enabling them to classify different entities.

Their robustness and adaptability allow them to function across several use cases, such as analyzing text or images, sentiment analysis, or recommending relevant items. With Python as a popular language for machine learning developers, it’s easy to integrate these AI models into various projects.

These use cases demonstrate the versatility and practical applications of Auto-GPT and Jarvis in the ever-evolving world of artificial intelligence.

Supported Technologies and Frameworks

In the race for AI supremacy between Auto-GPT and Jarvis, it’s essential to explore the technologies and frameworks employed by both tools. This section highlights the various frameworks, libraries, and platforms used by Auto-GPT and Jarvis, enabling better understanding and comparison.

Frameworks and Libraries

Auto-GPT, a language model developed by OpenAI, is based on the GPT-3 architecture. It is a state-of-the-art AI system for generating high-quality natural language content. Meanwhile, Jarvis is an AI bot created by Microsoft that consolidates several AI services into one tool.

• Auto-GPT benefits from the foundation of OpenAI’s GPT architecture, providing impressive language generation capabilities.
• Jarvis relies on Microsoft’s AI infrastructure, integrating various services into one user-friendly interface.

HuggingFace, a popular framework for natural language processing, likely influences both Auto-GPT and Jarvis. HuggingFace is notably adaptable to different language models and backend engines, making it a common choice for AI developers.

In fact, when running Jarvis (HuggingGPT) on Huggingface I realized that it can also create audio files. See here:

I haven’t seen Auto-GPT creating multimedia outputs, so this is a lovely demonstration of the potential expressiveness of Jarvis. Anyway, the resulting audio didn’t really say anything valuable, so more work is definitely needed!

Platforms

Both Auto-GPT and Jarvis are available on different platforms, enabling users to integrate these AI tools into their workflows. Auto-GPT, being developed by OpenAI, primarily functions through its command-line interface (CLI) for users to access and interact with the model.

On the other hand, Jarvis is a part of Microsoft’s AI ecosystem and can be integrated with various Microsoft services and platforms (source). NVIDIA, a leader in AI hardware and development, also plays a significant role in Jarvis, providing powerful GPU acceleration for optimized performance.

TLDR; Auto-GPT and Jarvis have extensive backing from major players in the AI industry, with OpenAI supporting Auto-GPT, and Microsoft and NVIDIA working together on Jarvis. These technologies and platforms significantly contribute to the capabilities and flexibility offered by both tools.

Installation and Setup

Next, I’ll guide you through the process of implementing Auto-GPT and Jarvis. Both of these AI technologies can power chatbots, assist with research, and perform various natural language processing tasks.

Keep in mind that while comparing AI technologies can feel like comparing to , understanding their usage will help you make an informed decision.

Auto-GPT

Auto-GPT is developed by OpenAI and is based on the GPT-3 architecture. To use Auto-GPT, you’ll need access to the OpenAI API. Once you have your API key, you can follow the documentation provided by OpenAI to set up authentication and make API calls to perform tasks like text generation or inference.

After you’ve created your OpenAI token (which you’ll need for both Auto-GPT and Jarvis), follow my detailed installation instructions on the Finxter blog:

Recommended: Setting Up Auto-GPT Any Other Way is Dangerous!

Jarvis

Jarvis is a AI assistant developed by Microsoft. To get started with Microsoft Jarvis, follow these steps:

1. Sign up for an API key from OpenAI, as described in the Auto-GPT section above.
2. Get your Huggingface token by following the steps in this guide.
3. Set up the authentication, using the instructions provided in the Beebom article that shows you how to configure Jarvis with the API keys.

Here you can see the Huggingface token in my case:

Community and Growth

Both Auto-GPT and Jarvis have attracted attention and engagement within the AI developer community. This section examines their popularity and developmental activity while highlighting key aspects, such as dependencies and API keys.

Popularity

Auto-GPT, in collaboration with open-source projects like Hugging Face, has caught the interest of developers. Its integration with Linux systems and flexible API key access fosters user adoption.

Comparatively, Jarvis also appeals to developers, being featured in the Top 5% of largest communities on Reddit. The platform provides powerful AI capabilities similar to Auto-GPT, inspiring numerous discussions and comparisons.

If you need a more quantitative measure of popularity, consider the GitHub stars of JARVIS (20k) and Auto-GPT (135k) making Auto-GPT seven times as popular!

Developer Activity

Auto-GPT’s developer activity is notable, primarily due to its ability to create autonomous AI agents within various applications. Continuous updates and experiments contribute to its growing knowledge-base and expanding community of collaborators.

Jarvis, on the other hand, boasts a vibrant GitHub presence, with insights on LibHunt illustrating the project’s growth in stars and recent commits. Its well-organized codebase and active maintenance encourage adoption by a broad range of developers.

Criticisms and Potential Issues

Limitations

Auto-GPT and Jarvis, while impressive, face limitations that can hinder their performance. Built on technologies like GPT-4 and GPT-3.5, these AI agents excel in generating text but can struggle with understanding context or specifics. As a result, they might produce creative yet irrelevant outputs.

Integration with varying platforms and other AI tools is crucial. Technologies like AgentGPT and generative AI can complement AI agents, yet their interoperability might be limited. Users should be aware of compatibility when using AI systems simultaneously.

Auto-generated content lacks a human touch. While shortening text á la Hemingway is doable, capturing the unique expressions and nuances a human writer offers proves challenging for AI.

Controversies

Ethics concerns arise in the world of AI agents. Auto-GPT may unintentionally generate inappropriate, biased, or misleading content due to its vast yet potentially outdated knowledge base. Users and developers should exercise caution and have checks in place to mitigate harmful outputs.

Security remains a pressing issue. AI services like GPT4All may be vulnerable to cyber-attacks and data breaches, so ensuring a secure environment for users is vital.

The widespread adoption of Auto-GPT and Jarvis raises questions about their impact on employment, as they automate traditionally manual tasks. Society must weigh the benefits of increased productivity against potential job displacement, and plan accordingly.

Future Developments

The potential of AI technologies like Auto-GPT and Jarvis is astounding, as both platforms continue to evolve in the realms of natural language processing and task automation. In this section, we will explore how these technologies may integrate with various tools and environments like Ubuntu, PyTorch, and CUDA for more efficient performance.

Ubuntu Integration

Auto-GPT and Jarvis can possibly be integrated with the popular Linux distribution, Ubuntu, to provide a seamless user experience. Ubuntu’s robust software ecosystem could enable developers to harness the power of these AI technologies more readily, enhancing the capabilities of chatbots and virtual assistants.

PyTorch and Torchaudio

Both Auto-GPT and Jarvis can potentially be expanded with libraries like PyTorch and torchaudio that aid machine learning and audio processing, respectively. These open-source libraries can help developers to build more sophisticated AI models, allowing the chatbots to analyze and process complex data.

CUDA Acceleration

The advanced computing prowess of AI technology can potentially be further boosted using CUDA, NVIDIA’s parallel computing platform. Utilizing CUDA’s GPU acceleration, both Auto-GPT and Jarvis can rapidly execute computational tasks, thus improving processing speeds and performance.

Demo Scripts

Developers might create demo scripts like run_gradio_demo.py to showcase the capabilities of Auto-GPT and Jarvis. These demo scripts can act as a practical introduction for users, highlighting the impressive language model-driven abilities of the chatbots to carry out complex tasks.

Integration with CNNs

In the future, it is plausible that Auto-GPT and Jarvis will incorporate convolutional neural networks (CNNs) for tasks like image analysis and recognition. With CNN integration, these AI technologies can potentially become more versatile and useful in a wider range of applications.

In summary, the developments for both Auto-GPT and Jarvis will likely involve integration with popular tools and libraries, enabling these technologies to further excel in the field of AI and push the boundaries of what is possible.

Alternative AI Models

In the world of artificial intelligence, AutoGPT and Jarvis are not the only game-changers. This section explores alternative AI models, focusing on Facebook’s Llama model and other notable competitors, and how they tackle various tasks such as entertainment, image recognition, machine learning, and classification.

Recommended: Choose the Best Open-Source LLM with This Powerful Tool

Facebook’s Llama Model

Facebook’s Llama model is gaining recognition for its impressive capabilities. It excels at tasks like machine learning and classification, allowing it to easily analyze vast amounts of data quickly and accurately.

Furthermore, Llama’s image recognition prowess makes it a strong contender in the AI race, as it can efficiently sift through images and identify relevant features.

Other Notable Competitors

Several other AI models are pushing boundaries in the industry:

• OpenAI’s CLIP combines text inputs and image recognition to create a versatile and powerful AI model that excels at tasks like generating content and image analysis.
• Google’s BERT focuses on natural language processing (NLP), enabling it to analyze and understand a wide range of linguistic content, from simple questions to complex sentences.
• NVIDIA’s GauGAN is designed for artistic creativity, transforming simple drawings into realistic images and digital art using machine learning techniques.

These alternative models demonstrate the growing diversity and expanding capabilities of artificial intelligence across various sectors, from entertainment to image analysis. By leveraging their strengths, businesses and researchers can harness the power of AI to solve critical problems and drive innovation.

Recommended: 11 Best ChatGPT Alternatives

OpenAI Glossary Cheat Sheet (100% Free PDF Download)

Finally, check out our free cheat sheet on OpenAI terminology, many Finxters have told me they love it!

Recommended: OpenAI Terminology Cheat Sheet (Free Download PDF)

• Auto-GPT vs Jarvis HuggingGPT: One Bot to Rule Them All
• HuggingGPT & JARVIS: “Advanced Artificial Intelligence” with … – YouTube
• HuggingGPT is INSANE! Microsoft JARVIS | Step by Step Guide

The post Auto-GPT vs Jarvis HuggingGPT: One Bot to Rule Them All appeared first on Be on the Right Side of Change.

Auto-GPT is an experimental, open-source autonomous AI agent based on the GPT-4 language model. It’s designed to chain together tasks autonomously, streamlining the multi-step prompting process commonly found in chatbots like ChatGPT.

Agent GPT boasts a user-friendly interface that makes AI interaction seamless even for individuals without coding experience.

AgentGPT is more expensive as you need to subscribe to a professional plan whereas with Auto-GPT you only need to provide an OpenAI API key without paying a third party.

While Auto-GPT pushes the boundaries of AI autonomy, Agent GPT focuses on a more intuitive user experience.

I created a table that subjectively summarizes the key similarities and differences:

Auto-GPT and Agent GPT Overview

In the realm of AI-powered language models, Auto-GPT and Agent GPT are two prominent technologies built on OpenAI’s API for automating tasks and language processing. This section provides a brief overview of both Auto-GPT and Agent GPT, focusing on their fundamentals and applications in various fields.

Auto-GPT Fundamentals

Auto-GPT is an open-source interface to large language models such as GPT-3.5 and GPT-4. It empowers users by self-guiding to complete tasks using a predefined task list. Requiring coding experience to be effectively used, Auto-GPT operates autonomously, making decisions and generating its own prompts .

With core capabilities in natural language processing, Auto-GPT applies to areas like data mining, content creation, and recommendation systems. Its autonomous nature makes it an ideal choice for developers seeking a more hands-off approach to task automation.

Recommended: 30 Creative AutoGPT Use Cases to Make Money Online

Agent GPT Fundamentals

In contrast, Agent GPT is a user-friendly application with a direct browser interface for task input. Eliminating the need for coding expertise, Agent GPT provides an intuitive user experience suited for a broader audience. While it depends on user inputs for prompt generation, it still boasts a powerful language model foundation.

Agent GPT finds applications in various fields, including virtual assistants, chatbots, and educational tools. Its user-friendliness and customizability make it an appealing choice for non-technical users seeking artificial general intelligence (AGI) support in their projects.

Technology Comparison

In this section, we will compare Auto-GPT and AgentGPT, focusing on their Language Models and Processing, Autonomy and Workflow, and User Interface and Accessibility. These AI agents have distinct advantages and offer a range of features for different user needs.

Language Models and Processing

Auto-GPT and AgentGPT both utilize OpenAI’s GPT-3 or GPT-4 API, which handles natural language processing and deep learning tasks. As a result, they can handle complex text-based tasks effectively. The primary difference lies in their implementation and target audience.

Autonomy and Workflow

Auto-GPT is designed to function autonomously by providing a task list and working towards task completion without much user interaction. This is ideal for developers with coding experience looking to automate more technical tasks in their workflow.

In contrast, AgentGPT is more user-friendly, requiring input through a direct browser interface. This makes AgentGPT a better choice for those without programming or AI expertise, as it simplifies the adoption and integration of the AI-powered tool in everyday tasks.

Autonomy of both is similar although you can keep Auto-GPT running much longer in your shell or terminal. Having the browser tab open in Agent GPT will only get you so far…

User Interface and Accessibility

Auto-GPT’s open-source nature means that it requires coding experience to be used effectively. While this may be perfect for developers, it can be a barrier for non-technical users.

Recommended: Setting Up Auto-GPT Any Other Way is Dangerous!

On the other hand, AgentGPT offers a straightforward browser interface, enabling users to input tasks without prior coding knowledge. This increased accessibility makes it a popular choice for individuals seeking AI assistance in a variety of professional settings.

Key Features

Generative AI and Content Creation

Auto-GPT and AgentGPT are both AI agents used for generating text and content creation, but they have some differences.

Auto-GPT is an open-source project on GitHub made by Toran Bruce Richards. AgentGPT, on the other hand, is designed for user-friendliness and accessibility for those without AI expertise, thus making it perfect for non-programmers.

Recommended: AutoGPT vs BabyAGI: Comparing OpenAI-Based Autonomous Agents

These AI agents employ advanced natural language processing algorithms to generate and structure content efficiently. They are optimized for various tasks, such as writing articles, creating summaries, and generating chatbot responses.

Machine Learning and Data Analysis

Both Auto-GPT and AgentGPT rely on cutting-edge machine learning algorithms to analyze and process data. Auto-GPT utilizes GPT-4 API for its core functionalities, while AgentGPT doesn’t rely on a specific GPT model.

Through their machine learning capabilities, these AI agents can not only create content but also analyze and process it effectively. This makes them perfect for applications like sentiment analysis, recommender systems, and classifications in a wide range of industries, from marketing to healthcare.

To sum up, Auto-GPT and AgentGPT are powerful and similar AI tools with a minor number of distinct features that cater to different needs. They both excel in generative AI and content creation, as well as machine learning and data analysis.

Personally, I found that AgentGPT is more fun!

Pricing and Costs

AI agents like Auto-GPT and AgentGPT have become increasingly popular for automating tasks, but the security concerns surrounding them and their API access need to be taken into account. In this section, we will discuss securing AI integration and obtaining an OpenAI API key for these AI agents.

AgentGPT is more expensive as you need to subscribe to a professional plan whereas with Auto-GPT you only need to provide an OpenAI API key without paying a third party.

Here’s a screenshot of the product pricing of AgentGPT:

The pricing of OpenAI API is very inexpensive, so Auto-GPT will be much cheaper for larger projects:

Use Cases and Industries

This section explores the distinct applications of Auto-GPT and AgentGPT in various industries, focusing on automation, marketing strategy, and customer service. We will examine how these AI agents can streamline tasks and enhance decision-making, contribute to marketing initiatives, and improve customer service through chatbots.

Automate Tasks and Decision-Making

Auto-GPT excels at autonomous operation, making it a powerful choice for automating tasks and decision-making.

Industries like finance, manufacturing, and logistics can benefit from Auto-GPT’s ability to process vast amounts of data, identify patterns, and execute decisions based on predefined goals.

On the other hand, AgentGPT requires a higher amount of human intervention but excels in more user-friendly applications, providing an intuitive interface that non-experts can easily navigate. I have yet to see somebody running Agent GPT for days whereas it’s easy to do with Auto-GPT.

Marketing Strategy

In the realm of marketing, AgentGPT’s intuitive user interface makes it the more suitable choice for strategizing and creating content.

Digital marketers can leverage the language model to develop relevant and engaging materials for various platforms, including social media, email campaigns, and blog posts.

While Auto-GPT can also generate content, its autonomous nature might not be as ideal for crafting customized and targeted marketing messages.

Development and Future Prospects

In the rapidly evolving field of AI, Auto-GPT and Agent GPT are two key players making significant strides. This section explores their open-source interfaces, repositories, and future research involving GPT-4 and beyond, delving into how these developments might shape the future of large language models.

By the way, if you’re interested in open-source developments in the large language models (LLM) space, check out this article on the Finxter blog!

6 New AI Projects Based on LLMs and OpenAI

Open-Source Interfaces and Repositories

In the world of artificial intelligence, open-source interfaces facilitate broader access to cutting-edge technology. Auto-GPT is one such agent, available as an open-source project on GitHub.

Developed by Toran Bruce Richards aka “Significant Gravitas”, its accessibility to those with coding experience helps to foster innovation in AI applications.

On the other hand, Agent GPT is a more expensive and user-friendly platform geared toward a wider audience, requiring less technical know-how for utilization.

GPT-4 and Future Research

As AI research continues, the focus has shifted to larger language models—like GPT-4—that are expected to outperform their predecessors.

Auto-GPT, as a self-guiding agent capable of task completion via a provided task list, is primed for incorporation with future GPT iterations. Meanwhile, BabyAGI is another emerging language model, developed simultaneously with agents like Auto-GPT and Agent GPT, in response to the growing generative AI domain.

TLDR; Auto-GPT and Agent GPT contribute to a brighter future in AI research, with the former offering a more technical approach that’s inexpensive and highly customizable and the latter catering to a less code-oriented user base that is willing to pay more for the convenience.

The introduction of GPT-4 represents a step toward more advanced and efficient AI applications, ensuring that the race for better language models continues.

OpenAI Glossary Cheat Sheet (100% Free PDF Download)

Finally, check out our free cheat sheet on OpenAI terminology, many Finxters have told me they love it!

Recommended: OpenAI Terminology Cheat Sheet (Free Download PDF)

References

• openaimaster.com
• docs.kanaries.net
• teccgadgets.com
• mashable.com
• openaimaster.com

The post Auto-GPT vs Agent GPT: Who’s Winning in Autonomous LLM Agents? appeared first on Be on the Right Side of Change.