Get Started Using BabyAGI for Beginners: Setup & Usage

BabyAGI is an easy-to-use Python script that helps automate brainstorming and task management.

Given a specific goal (objective) and a starting point (initial task), it generates creative ideas, organizes them into tasks, and prioritizes those tasks to guide you towards achieving your goal.

It uses the powerful language understanding of OpenAI’s GPT API and Pinecone.io, a service that helps store and organize data, to perform its tasks effectively (more on this later).

In this article, we will walk you through the setup and usage of BabyAGI, and explain the basics of its underlying technology. By the end, you’ll have a solid understanding of how to harness the power of BabyAGI for your own projects, as well as its potential applications and limitations.

To give you an idea of what it can do, here are a few quick examples of what BabyAGI can do:

1. Writing: it can take your goal of “writing a sci-fi novel” and initial task “brainstorm story themes” to generate a list of creative themes, characters, and plotlines, while prioritizing tasks to guide you through the writing process.
2. Organizing an event: it can take your goal of “organizing a successful charity event” and initial task “identify potential event themes” to generate a list of creative themes, venue ideas, and sponsorship opportunities, while prioritizing tasks to guide you through the event planning process.
3. Product development: it take your goal of “developing a new mobile app” and initial task “research popular app categories” to generate a list of potential app ideas, user interface designs, and feature sets, while prioritizing tasks to guide you through the app development process.

Quick Video Demo of BabyAGI

Here’s a demo of me asking BabyAGI to help me find topics for my blog. Even though it doesn’t browse the web, using all the knowledge it has until 2021, I’m quite happy with the direction it’s going.

Requirements

To install and use BabyAGI you need the following:

• An OpenAI API Key. This implies that you have a paid OpenAI account. If you’ve signed up in the last 3 months you likely have $5 free credits to your account, which is an excellent amount to use the service with. If the concept of an API is new to you, check out our article on the ChatGPT API.
• A Pinecone.io API Key. For this you just need to sign up for a free account with Pinecone.io
• Python 3.7 or later and Git installed
• (Optional) Virtualenvwrapper which is a Python package that allows you to create isolated (virtual) environments for Python. Because you’ll install some dependencies that BabyAGI uses, and it’s a good idea to keep them isolated. You may try more Python based software in the future, which have dependencies of their own, and sometimes conflicts happen between packages. You don’t need to use virtualenvwrapper to run BabyAGI, but I recommend it and it’s how I do it.

(Optional) Set OpenAI Usage Limit

Please keep in mind that your OpenAI API account charges you based on usage. Since BabyAGI loops over what it’s “thinking”, if left unsupervised for a long time it can use up more funds than you’re comfortable with.

A good idea is to set usage limits in OpenAI https://platform.openai.com/account/billing/limits:

• Hard Limit: Is where OpenAI will restrict further usage if you cross that threshold.
• Soft Limit: You’ll receive an email notification when you reach that threshold.

You can set lower limits than mine. So far I’ve used Auto-GPT and BabyAGI multiple times and I’ve reached $3.73 this past week.

Install Python

Python is a versatile programming language that’s user-friendly and widely used for AI projects, including BabyAGI. Even if you’re not familiar with it, no worries!

You only need to install Python to run BabyAGI.

To install it use this short tutorial that shows how to install it for Windows/Mac or Linux https://python.land/installing-python.

Install Git

To install Git go here (it’s a simple tutorial) https://github.com/git-guides/install-git and follow the instructions corresponding to your operating system.

Git is a tool that helps developers keep track of their code, collaborate with others, and handle different stages of a project. Imagine it as a smart “undo” and “redo” button that makes organizing your projects a breeze.

GitHub is an online platform where people store and share their projects, making it easy for others to access, contribute, or learn from them. BabyAGI is one of these projects.

For our purposes, you just need to know how to download a BabyAGI, or “pull” it, from GitHub.

After installing Git on your computer, we’ll show you how to grab the BabyAGI repo in a few easy steps, so you can start using it in no time.

Install virtualenvwrapper (Optional)

I also recommend using virtualenvwrapper to install BabyAGI, although this is optional.

Virtualenv and virtualenvwrapper are tools used in Python to create isolated environments for your projects. They help keep each project’s packages and dependencies separate, avoiding conflicts between them. You can think of it like a sandbox, or VirtualBox or VMWare (if you’re familiar with them) but for Python.

Virtualenv is the basic tool that creates these environments, while virtualenvwrapper is an extension that makes managing multiple environments easier and more convenient.

For BabyAGI, using a virtual environment is beneficial because it has specific packages it depends on. By creating a separate environment, you ensure that these packages won’t interfere with other projects, making it safer and more organized.

We’ll easily install it using pip that comes with Python. Pip is a tool used in Python for installing and managing packages, which are reusable pieces of code or libraries that add functionality to your projects.

With pip, you can easily install, update, and remove packages from your Python environment.

Install virtualenvwrapper on Linux/OS X

Open a terminal and run:

pip install virtualenvwrapper

Install virtualenvwrapper on Windows

Open cmd or Powershell or your preferred terminal emulator and run:

pip install virtualenvwrapper-win

Create & Activate a Virtual Environment

Now that we’ve got virtualenvwrapper installed we can easily create a virtual environment and then we’ll install BabyAGI.

To do this run your operating system’s terminal and navigate to the directory where you’d like to install BabyAGI.

Then run the following command replacing name_of_virtual_environment with whatever name you want, like autogpt.

mkvirtualenv name_of_virtual_environment

mkvirtualenv autogpt

Deactivate & Reactivate a Virtual Environment

To deactivate a virtual environment simply run the following command (or close the terminal):

deactivate

To reactivate the virtual environment run:

workon name_of_virtual_environment

Install BabyAGI

Download BabyAGI from Github

To install BabyAGI on your computer you just have to download it from Github and then install some of its’ dependencies.

To do this, navigate the the directory where you want it downloaded, activate the virtual environment you want to use (if you want to use one), and run:

git clone https://github.com/yoheinakajima/babyagi.git

Next cd into the newly created BabyAGI directory and run the following command to install BabyAGI’s dependencies. This will take a minute or so.

pip install -r requirements.txt

Configure BabyAGI with OpenAI and Pinecone API Keys

We’ll need these API keys so the BabyAGI script can use OpenAI GPT3.5 or 4 (depending which you prefer), and Pinecone.io‘s service where it will store information so it works as long-term memory.

OpenAI API Key

Next we’ll need to use OpenAI’s API Keys so that BabyAGI can use the GPT API.

You can generate an API key here https://platform.openai.com/account/api-keys.

Pinecone.io API Key

If you don’t know what Pinecone.io is, you can check the explanation below in our FAQ section.

First sign up for a free Pinecone.io account here https://app.pinecone.io/.

Next you don’t have to do anything, except grab your Pinecone API Key and Pinecone Environment. BabyAGI will take care of the rest when you run it.

To do this, once logged in look in your left sidebar and click on API Keys.

We’ll need both PINECONE_ENVIRONMENT and PINECONE_API_KEY.

Configure The .env.template File

BabyAGI will look for a file called .env in its’ directory. We’re provided with an .env.template file by default.

1. First rename the .env.template file to .env
   • If you don’t see the .env.template file make sure you have Show hidden files enabled in your folder options. This differs depending on your operating system.
2. Next we’ll edit the .env file.
   • OPENAI_API_KEY: This is your OpenAI API key.
   • OPENAI_API_MODEL: This is the GPT model you want to use. I’m using GPT-4, which is more expensive. You can use any other listed here https://platform.openai.com/docs/models/gpt-3-5
   • PINECONE_API_KEY: Your Pinecone API Key
   • PINECONE_ENVIRONMENT: The Pinecone environment.
   • OBJECTIVE: This is where you define the objective you want BabyAGI to think about.
   • INITIAL_TASK: What task you want BabyAGI to start with. Develop a task list is usually a good task to start with.

# cp .env.example .env
# Edit your .env file with your own values
# Don't commit your .env file to git/push to GitHub!
# Don't modify/delete .env.example unless adding extensions to the project
# which require new variable to be added to the .env file

# API CONFIG
OPENAI_API_KEY=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
OPENAI_API_MODEL=gpt-4 # alternatively, gpt-4, text-davinci-003, etc
PINECONE_API_KEY=6trc8def-23zx-543r-76g4-8hgf2v98765c
PINECONE_ENVIRONMENT=asia-southeast1-gcp

# TABLE CONFIG
TABLE_NAME=test-table

# INSTANCE CONFIG
BABY_NAME=BabyAGI

# RUN CONFIG
OBJECTIVE=Find popular topics that don't have enough documentation, for articles for my Linux tutorial blog
# For backwards compatibility
# FIRST_TASK can be used instead of INITIAL_TASK
INITIAL_TASK=Develop a task list

# Extensions
# List additional extensions to load (except .env.example!)
DOTENV_EXTENSIONS=
# Set to true to enable command line args support
ENABLE_COMMAND_LINE_ARGS=false

Save and close the file when you’re done.

Run BabyAGI

Now we can finally run BabyAGI.

To do this navigate into your BabyAGI directory and activate your virtual environment (if you decided to use a virtual environment) and run:

python babyagi.py

After which it will use the OBJECTIVE and Initial task that you set in the .env file and it will continuously brainstorm.

Stop BabyAGI

To stop BabyAGI just press Ctrl+C or close the terminal. Since it runs continuously, always monitor it and also best to set a spending limit in OpenAI.

Update BabyAGI

BabyAGI is under continous development, as such it’s updated nearly daily.

To keep it updated you can simply cd using the terminal into where you downloaded the repository and run:

git pull

It updates your local copy of a project with the latest changes from the remote repository.

Frequently Asked Questions

BabyAGI vs Auto-GPT

Unlike Auto-GPT, BabyAGI does not browse external resources, which can be advantageous in certain situations. By focusing on brainstorming, BabyAGI avoids interrupting its train of thought by searching for information on the internet.

This approach makes BabyAGI an excellent tool for brainstorming and ideation, either as a standalone application or as a component within a larger system.

A combination between the two would be great. Auto-GPT has a tendency to jump into searching for browsing the internet without having a solid plan, and it needs additional supervision.

On the other hand BabyAGI is forced to rely on it’s knowledge cutoff in September 2021.

How to Access the Internet with BabyAGI

As of writing this article, BabyAGI doesn’t have the capability to access the internet or external resources.

I haven’t looked into it very much yet, but my bet would be that you could use BabyAGI with external sources by using it as a component of LangChain. You can check a demo of BabyAGI used with LangChain here: https://python.langchain.com/en/latest/use_cases/agents/baby_agi.html

I’m not clear where it accesses information on the internet in that example, but I’ll update this article when I have a clearer picture.

What is Pinecone.io and Why Do We Need It?

Pinecone.io is a vector database service. There are other vector databases that you can host on your computer, like Chroma or Weaviate.

Vector databases are like special libraries that store and manage data in a unique way. Instead of keeping information as text or images, they convert it into a series of numbers called “vectors.”

These vectors capture the essential details of the original data, making it easier for computers to understand and work with.

When you want to find or compare information in a vector database, the system looks at the numbers in the vectors and calculates their similarity.

This helps the computer quickly identify related data points or find the most relevant information based on your search query. In short, vector databases are powerful tools for organizing and retrieving complex data more efficiently.

Essentially, Pinecone acts as BabyAGI’s long-term memory, enabling it to remember past results and make better decisions as it works through the tasks.

Conclusion

In conclusion, BabyAGI is a powerful and versatile task management system that can really help with brainstorming, task creation, and prioritization.

By harnessing the capabilities of OpenAI’s GPT API and Pinecone.io, it can be employed across various industries to optimize workflows and enhance decision-making.

Hopefully this guide helped you set up and understand BabyAGI. As you begin to experiment with BabyAGI, you’ll likely discover even more ways it can be tailored to your specific needs and goals, making it a valuable addition to your toolkit.

If you encountered any issues or have any questions feel free to leave a comment and we’ll get back to you as soon as we can.

Resources & Acknowledgements

• BabyAGI Github Repo by Yohei Nakajima
• BabyAGI – New System of Autonomous AI Agents with LangChain by 1littlecoder – Where I first heard about BabyAGI
• BabyAGI User Guide with LangChain – A guide explaining how to use LangChain to create your own BabyAGI like script.