A Modular Auto-GPT Framework
L♾️pGPT is a re-implementation of the popular Auto-GPT project as a proper python package, written with modularity and extensibility in mind.
- "Plug N Play" API - Extensible and modular "Pythonic" framework, not just a command line tool. Easy to add new features, integrations and custom agent capabilities, all from python code, no nasty config files!
- GPT 3.5 friendly - Better results than Auto-GPT for those who don't have GPT-4 access yet!
- Minimal prompt overhead - Every token counts. We are continuously working on getting the best results with the least possible number of tokens.
- Human in the Loop - Ability to "course correct" agents who go astray via human feedback.
- Full state serialization - Pick up where you left off; L♾️pGPT can save the complete state of an agent, including memory and the states of its tools to a file or python object. No external databases or vector stores required (but they are still supported)!
pip install loopgptpip install git+https://www.github.com/farizrahman4u/loopgpt.git@maingit clone https://www.github.com/farizrahman4u/loopgpt.git@main
cd loopgpt
python setup.py developYou must set your OpenAI API Key 🔑 in your environment variables for anything to work. See the Requirements secion below.
from loopgpt.agent import Agent
agent = Agent()L♾️pGPT uses gpt-3.5-turbo by default and all outputs shown here are made using it. GPT-4 users can set model="gpt-4" instead:
agent = Agent(model="gpt-4")agent.name = "ResearchGPT"
agent.description = "an AI assistant that researches and finds the best tech products"
agent.goals = [
"Search for the best headphones on Google",
"Analyze specs, prices and reviews to find the top 5 best headphones",
"Write the list of the top 5 best headphones and their prices to a file",
"Summarize the pros and cons of each headphone and write it to a different file called 'summary.txt'",
]And we're off! Let's run the Agent🕵️'s CLI:
agent.cli()You can exit the CLI by typing "exit".
If continuous is set to True, the agent will not ask for the user's permission to execute commands. It may go into infinite loops, so use it at your own risk!
agent.cli(continuous=True)You can run L♾️pGPT directly from the command line without having to write any python code as well:
loopgpt runRun loopgpt --help to see all the available options.
L♾️pGPT agents come with a set of builtin tools which allows them to perform various basic tasks such as searching the web, filesystem operations, etc. You can view these tools with print(agent.tools).
In addition to these builtin tools, you can also add your own tools to the agent's toolbox.
Let's create WeatherGPT, an AI assistant for all things weather.
A tool inherits from BaseTool and you only need to override 3 methods to get your tool up and running!
args: A dictionary describing the tool's arguments and their descriptions.resp: A dictionary describing the tool's response and their descriptions.run: The tool's main logic. It takes the tool's arguments as input and returns the tool's response.
from loopgpt.tools import BaseTool
class GetWeather(BaseTool):
@property
def args(self):
return {"city": "name of the city"}
@property
def resp(self):
return {"report": "The weather report for the city"}
def run(self, city):
...L♾️pGPT gives a default ID and description to your tool but you can override them if you'd like:
class GetWeather(BaseTool):
...
@property
def id(self):
return "get_weather_command"
@property
def desc(self):
"""A description is recommended so that the agent knows more about what the tool does"""
return "Quickly get the weather for a given city"Now let's define what our tool will do in its run method:
import requests
# Define your custom tool
class GetWeather(BaseTool):
...
def run(self, city):
try:
url = "https://wttr.in/{}?format=%l+%C+%h+%t+%w+%p+%P".format(city)
data = requests.get(url).text.split(" ")
keys = ("location", "condition", "humidity", "temperature", "wind", "precipitation", "pressure")
data = {"report": dict(zip(keys, data))}
return data
except Exception as e:
return {"report": f"An error occured while getting the weather: {e}."}That's it! You've built your first custom tool. Let's register it with a new agent and run it:
import loopgpt
# Create Agent
agent = loopgpt.Agent()
agent.name = "WeatherGPT"
agent.description = "an AI assistant that tells you the weather"
agent.goals = [
"Get the weather for NewYork and Beijing",
"Give the user tips on how to dress for the weather in NewYork and Beijing",
"Write the tips to a file called 'dressing_tips.txt'"
]
# Register custom tool type
# This is actually not required here, but is required when you load a saved agent with custom tools.
loopgpt.tools.register_tool_type(GetWeather)
# Register Tool
weather_tool = GetWeather()
agent.tools[weather_tool.id] = weather_tool
# Run the agent's CLI
agent.cli()Let's take a look at the dressing_tips.txt file that WeatherGPT wrote for us:
dressing_tips.txt
- It's Clear outside with a temperature of +10°C in Beijing. Wearing a light jacket and pants is recommended.
- It's Overcast outside with a temperature of +11°C in New York. Wearing a light jacket, pants, and an umbrella is recommended.
Unlike Auto-GPT, the agent does not terminate when the user denies the execution of a command. Instead it asks the user for feedback to correct its course.
To correct the agent's course, just deny execution and provide feedback:
The agent has updated its course of action:
You can save an agent's state to a json file with:
agent.save("ResearchGPT.json")This saves the agent's configuration (model, name, description etc) as well as its internal state (conversation state, memory, tool states etc).
You can also save just the confifguration by passing include_state=False to agent.save():
agent.save("ResearchGPT.json", include_state=False)Then pick up where you left off with:
import loopgpt
agent = loopgpt.Agent.load("ResearchGPT.json")
agent.cli()or by running the saved agent from the command line:
loopgpt run ResearchGPT.jsonYou can convert the agent state to a json compatible python dictionary instead of writing to a file:
agent_config = agent.config()To get just the configuration without the internal state:
agent_config = agent.config(include_state=False)To reload the agent from the config, use:
import loopgpt
agent = loopgpt.Agent.from_config(agent_config)- Python 3.8+
- An OpenAI API Key
- Google Chrome
For official google search support:
- Google API Key (for Google Search)
- Set environment variable
GOOGLE_API_KEYto the API key
- Set environment variable
- Google Custom Search Engine ID (also for Google Search)
- Set environment variable
CUSTOM_SEARCH_ENGINE_IDto the CSE ID
- Set environment variable
In case these are absent, L♾️pGPT will fall back to using DuckDuckGo Search
We need A LOT of Help! Please open an issue or a PR if you'd like to contribute.
Need help? Join our Discord.