diff --git a/.env.example b/.env.example
new file mode 100644
index 00000000..1a056460
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,52 @@
+# 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_MODEL can be used instead
+# Special values:
+# human - use human as intermediary with custom LLMs
+# llama - use llama.cpp with Llama, Alpaca, Vicuna, GPT4All, etc
+LLM_MODEL=gpt-3.5-turbo # alternatively, gpt-4, text-davinci-003, etc
+
+LLAMA_MODEL_PATH= # ex. models/llama-13B/ggml-model.bin
+#LLAMA_THREADS_NUM=8 # Set the number of threads for llama (optional)
+
+OPENAI_API_KEY=
+OPENAI_TEMPERATURE=0.0
+
+# STORE CONFIG
+# TABLE_NAME can be used instead
+RESULTS_STORE_NAME=baby-agi-test-table
+
+# Weaviate config
+# Uncomment and fill these to switch from local ChromaDB to Weaviate
+# WEAVIATE_USE_EMBEDDED=true
+# WEAVIATE_URL=
+# WEAVIATE_API_KEY=
+
+# Pinecone config
+# Uncomment and fill these to switch from local ChromaDB to Pinecone
+# PINECONE_API_KEY=
+# PINECONE_ENVIRONMENT=
+
+# COOPERATIVE MODE CONFIG
+# BABY_NAME can be used instead
+INSTANCE_NAME=BabyAGI
+COOPERATIVE_MODE=none # local
+
+# RUN CONFIG
+OBJECTIVE=Solve world hunger
+# For backwards compatibility
+# FIRST_TASK can be used instead of INITIAL_TASK
+INITIAL_TASK=Develop a task list
+
+# Extensions
+# List additional extension .env files to load (except .env.example!)
+DOTENV_EXTENSIONS=
+# Set to true to enable command line args support
+ENABLE_COMMAND_LINE_ARGS=false
+
+
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..8308de8f
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+*.py text eol=lf
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index b19c673c..a4398dde 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,164 +1,24 @@
-# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-# Usually these files are written by a python script from a template
-# before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-# For a library or package, you might want to ignore these files since the code is
-# intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-# However, in case of collaboration, if having platform-specific dependencies or dependencies
-# having no cross-platform support, pipenv may install dependencies that don't work, or not
-# install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-# This is especially recommended for binary packages to ensure reproducibility, and is more
-# commonly ignored for libraries.
-# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-# in version control.
-# https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
.env
-.venv
+.env.*
env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
+.venv
+*venv/
-# pytype static type analyzer
-.pytype/
+.vscode/
+.idea/
-# Cython debug symbols
-cython_debug/
+models
+llama/
-# PyCharm
-# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-# and can be added to the global gitignore or merged into this file. For a more nuclear
-# option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+babycoder/playground/*
+babycoder/playground_data/*
+babycoder/objective.txt
-# Custom ignores
-funztionz.db
-encryption_key.json
+# for node
+chroma/
+node_modules/
+.DS_Store
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..40eb5822
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,28 @@
+repos:
+ - repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v4.4.0
+ hooks:
+ - id: trailing-whitespace
+ - id: end-of-file-fixer
+ - id: check-yaml
+ - id: check-added-large-files
+ - id: check-merge-conflict
+ - id: debug-statements
+ - id: requirements-txt-fixer
+ files: requirements.txt
+
+ - repo: https://github.com/psf/black
+ rev: 23.3.0
+ hooks:
+ - id: black
+
+ - repo: https://github.com/pycqa/isort
+ rev: 5.11.5
+ hooks:
+ - id: isort
+
+ - repo: https://github.com/pycqa/flake8
+ rev: 6.0.0
+ hooks:
+ - id: flake8
+ args: ["--max-line-length=140"]
diff --git a/.replit b/.replit
deleted file mode 100644
index e95a79b1..00000000
--- a/.replit
+++ /dev/null
@@ -1,27 +0,0 @@
-entrypoint = "main.py"
-modules = ["python-3.11"]
-
-[nix]
-channel = "stable-24_05"
-
-[unitTest]
-language = "python3"
-
-[gitHubImport]
-requiredFiles = [".replit", "replit.nix"]
-
-[deployment]
-run = ["python3", "main.py"]
-deploymentTarget = "cloudrun"
-
-[[ports]]
-localPort = 5000
-externalPort = 5000
-
-[[ports]]
-localPort = 8000
-externalPort = 8000
-
-[[ports]]
-localPort = 8080
-externalPort = 80
diff --git a/CNAME b/CNAME
new file mode 100644
index 00000000..a43bb23b
--- /dev/null
+++ b/CNAME
@@ -0,0 +1 @@
+babyagi.org
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..e91d8afd
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+ENV PIP_NO_CACHE_DIR=true
+WORKDIR /tmp
+RUN apt-get update && apt-get install build-essential -y
+
+COPY requirements.txt /tmp/requirements.txt
+RUN pip install -r requirements.txt
+
+WORKDIR /app
+COPY . /app
+ENTRYPOINT ["./babyagi.py"]
+EXPOSE 8080
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..1edce33f
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Yohei Nakajima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/MANIFEST.in b/MANIFEST.in
deleted file mode 100644
index 9d531ff2..00000000
--- a/MANIFEST.in
+++ /dev/null
@@ -1,25 +0,0 @@
-# Include the README and LICENSE
-include README.md
-include LICENSE
-
-# Include all package directories and their contents
-recursive-include babyagi *
-
-# Include examples
-recursive-include examples *
-
-# Exclude specific sensitive or unwanted files
-exclude encryption_key.json
-exclude funztionz.db
-
-# Exclude other unnecessary files
-global-exclude *.pyc
-global-exclude __pycache__/
-
-# Exclude .git and .gitignore
-global-exclude .git
-global-exclude .gitignore
-
-# Exclude .egg-info directory and files
-global-exclude *.egg-info
-global-exclude *.egg-info/*
diff --git a/README.md b/README.md
index 7731c355..0c3e4539 100644
--- a/README.md
+++ b/README.md
@@ -1,256 +1,129 @@
-# BabyAGI
+# Translations:
-> [!NOTE]
-> The original BabyAGI from March 2023 introduced task planning as a method for developing autonomous agents. This project has been archived and moved to the [babyagi_archive](https://github.com/yoheinakajima/babyagi_archive) repo (September 2024 snapshot).
+[](docs/README-ar.md)
+[](docs/README-fr.md)
+[](docs/README-pl.md)
+[](docs/README-pt-br.md)
+[](docs/README-ro.md)
+[](docs/README-ru.md)
+[](docs/README-si.md)
+[](docs/README-es.md)
+[](docs/README-tr.md)
+[](docs/README-ua.md)
+[](docs/README-cn.md)
+[](docs/README-zh-tw.md)
+[](docs/README-ja.md)
+[](docs/README-ko.md)
+[](docs/README-hu.md)
+[](docs/README-fa.md)
+[](docs/README-de.md)
+[](docs/README-in.md)
-> [!CAUTION]
-> This is a framework built by Yohei who has never held a job as a developer. The purpose of this repo is to share ideas and spark discussion and for experienced devs to play with. Not meant for production use. Use with cautioun.
----
+# Objective
-This newest BabyAGI is an experimental framework for a self-building autonomous agent. Earlier efforts to expand BabyAGI have made it clear that the optimal way to build a general autonomous agent is to build the simplest thing that can build itself.
+This Python script is an example of an AI-powered task management system. The system uses OpenAI and vector databases such as Chroma or Weaviate to create, prioritize, and execute tasks. The main idea behind this system is that it creates tasks based on the result of previous tasks and a predefined objective. The script then uses OpenAI's natural language processing (NLP) capabilities to create new tasks based on the objective, and Chroma/Weaviate to store and retrieve task results for context. This is a pared-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023).
-The core is a new function framework (**functionz**) for storing, managing, and executing functions from a database. It offers a graph-based structure for tracking imports, dependent functions, and authentication secrets, with automatic loading and comprehensive logging capabilities. Additionally, it comes with a dashboard for managing functions, running updates, and viewing logs.
+This README will cover the following:
-## Table of Contents
+- [How the script works](#how-it-works)
-- [Quick Start](#quick-start)
-- [Basic Usage](#basic-usage)
-- [Function Metadata](#function-metadata)
-- [Function Loading](#function-loading)
-- [Key Dependencies](#key-dependencies)
-- [Execution Environment](#execution-environment)
- - [Log](#log)
-- [Dashboard](#dashboard)
-- [Pre-loaded Functions](#pre-loaded-functions)
-- [Future/Draft Features](#futuredraft-features)
-- [API Reference](#api-reference)
-- [Contributing](#contributing)
-- [License](#license)
+- [How to use the script](#how-to-use)
-## Quick Start
+- [Supported Models](#supported-models)
-To quickly check out the dashboard and see how it works:
+- [Warning about running the script continuously](#continuous-script-warning)
-1. **Install BabyAGI:** (PIP INSTALL WILL NOT WORK UNTIL WE PUSH TO PYPI, USE GIT CLONE FOR NOW)
+# How It Works
- ```bash
- pip install babyagi
- ```
+The script works by running an infinite loop that does the following steps:
-2. **Import BabyAGI and load the dashboard:**
+1. Pulls the first task from the task list.
+2. Sends the task to the execution agent, which uses OpenAI's API to complete the task based on the context.
+3. Enriches the result and stores it in [Chroma](https://docs.trychroma.com)/[Weaviate](https://weaviate.io/).
+4. Creates new tasks and reprioritizes the task list based on the objective and the result of the previous task.
+
- ```python
- import babyagi
+
- if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
- ```
+The `execution_agent()` function is where the OpenAI API is used. It takes two parameters: the objective and the task. It then sends a prompt to OpenAI's API, which returns the result of the task. The prompt consists of a description of the AI system's task, the objective, and the task itself. The result is then returned as a string.
-3. **Navigate to the dashboard:**
+The `task_creation_agent()` function is where OpenAI's API is used to create new tasks based on the objective and the result of the previous task. The function takes four parameters: the objective, the result of the previous task, the task description, and the current task list. It then sends a prompt to OpenAI's API, which returns a list of new tasks as strings. The function then returns the new tasks as a list of dictionaries, where each dictionary contains the name of the task.
- Open your browser and go to `http://localhost:8080/dashboard` to access the BabyAGI dashboard.
-
-## Basic Usage
+The `prioritization_agent()` function is where OpenAI's API is used to reprioritize the task list. The function takes one parameter, the ID of the current task. It sends a prompt to OpenAI's API, which returns the reprioritized task list as a numbered list.
-Start by importing `babyagi` and registering your functions. Here's how to register two functions, where one depends on the other:
+Finally, the script uses Chroma/Weaviate to store and retrieve task results for context. The script creates a Chroma/Weaviate collection based on the table name specified in the TABLE_NAME variable. Chroma/Weaviate is then used to store the results of the task in the collection, along with the task name and any additional metadata.
-```python
-import babyagi
+# How to Use
-# Register a simple function
-@babyagi.register_function()
-def world():
- return "world"
+To use the script, you will need to follow these steps:
-# Register a function that depends on 'world'
-@babyagi.register_function(dependencies=["world"])
-def hello_world():
- x = world()
- return f"Hello {x}!"
+1. Clone the repository via `git clone https://github.com/yoheinakajima/babyagi.git` and `cd` into the cloned repository.
+2. Install the required packages: `pip install -r requirements.txt`
+3. Copy the .env.example file to .env: `cp .env.example .env`. This is where you will set the following variables.
+4. Set your OpenAI API key in the OPENAI_API_KEY and OPENAI_API_MODEL variables. In order to use with Weaviate you will also need to setup additional variables detailed [here](docs/weaviate.md).
+5. Set the name of the table where the task results will be stored in the TABLE_NAME variable.
+6. (Optional) Set the name of the BabyAGI instance in the BABY_NAME variable.
+7. (Optional) Set the objective of the task management system in the OBJECTIVE variable.
+8. (Optional) Set the first task of the system in the INITIAL_TASK variable.
+9. Run the script: `python babyagi.py`
-# Execute the function
-print(babyagi.hello_world()) # Output: Hello world!
+All optional values above can also be specified on the command line.
-if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
-```
-
-## Function Metadata
-
-Functions can be registered with metadata to enhance their capabilities and manage their relationships. Here's a more comprehensive example of function metadata, showing logical usage of all fields:
-
-```python
-import babyagi
-
-@babyagi.register_function(
- imports=["math"],
- dependencies=["circle_area"],
- key_dependencies=["openai_api_key"],
- metadata={
- "description": "Calculates the volume of a cylinder using the circle_area function."
- }
-)
-def cylinder_volume(radius, height):
- import math
- area = circle_area(radius)
- return area * height
-```
-
-**Available Metadata Fields:**
-
-- `imports`: List of external libraries the function depends on.
-- `dependencies`: List of other functions this function depends on.
-- `key_dependencies`: List of secret keys required by the function.
-- `metadata["description"]`: A description of what the function does.
-
-## Function Loading
+# Running inside a docker container
-In addition to using `register_function`, you can use `load_function` to load plugins or draft packs of functions. BabyAGI comes with built-in function packs, or you can load your own packs by pointing to the file path.
+As a prerequisite, you will need docker and docker-compose installed. Docker desktop is the simplest option https://www.docker.com/products/docker-desktop/
-You can find available function packs in `babyagi/functionz/packs`.
+To run the system inside a docker container, setup your .env file as per steps above and then run the following:
-**Loading Custom Function Packs:**
-
-```python
-import babyagi
-
-# Load your custom function pack
-babyagi.load_functions("path/to/your/custom_functions.py")
```
-
-This approach makes function building and management easier by organizing related functions into packs.
-
-## Key Dependencies
-
-You can store `key_dependencies` directly from your code or manage them via the dashboard.
-
-**Storing Key Dependencies from Code:**
-
-```python
-import babyagi
-
-# Add a secret key
-babyagi.add_key_wrapper('openai_api_key', 'your_openai_api_key')
+docker-compose up
```
-**Adding Key Dependencies via Dashboard:**
-
-Navigate to the dashboard and use the **add_key_wrapper** feature to securely add your secret keys.
-
-## Execution Environment
-
-BabyAGI automatically loads essential function packs and manages their dependencies, ensuring a seamless execution environment. Additionally, it logs all activities, including the relationships between functions, to provide comprehensive tracking of function executions and dependencies.
-
-### Log
-
-BabyAGI implements a comprehensive logging system to track all function executions and their interactions. The logging mechanism ensures that every function call, including its inputs, outputs, execution time, and any errors, is recorded for monitoring and debugging purposes.
-
-**Key Logging Features:**
-
-- **Execution Tracking:** Logs when a function starts and finishes execution, including the function name, arguments, keyword arguments, and execution time.
-
-- **Error Logging:** Captures and logs any errors that occur during function execution, providing detailed error messages for troubleshooting.
-
-- **Dependency Management:** Automatically resolves and logs dependencies between functions, ensuring that all required functions and libraries are loaded before execution.
-
-- **Trigger Logging:** Logs the execution of triggered functions, detailing which functions were triggered by others and their respective execution outcomes.
-
-- **Comprehensive Records:** Maintains a history of all function executions, enabling users to review past activities, understand function relationships, and analyze performance metrics.
-
-**How Triggers Work:**
-
-Triggers are mechanisms that allow certain functions to be automatically executed in response to specific events or actions within the system. For example, when a function is added or updated, a trigger can initiate the generation of a description for that function.
-
-Triggers enhance the autonomy of BabyAGI by enabling automated workflows and reducing the need for manual intervention. However, it's essential to manage triggers carefully to avoid unintended recursive executions or conflicts between dependent functions.
-
-## Dashboard
-
-The BabyAGI dashboard offers a user-friendly interface for managing functions, monitoring executions, and handling configurations. Key features include:
-
-- **Function Management:** Register, deregister, and update functions directly from the dashboard.
-
-- **Dependency Visualization:** View and manage dependencies between functions to understand their relationships.
-
-- **Secret Key Management:** Add and manage secret keys securely through the dashboard interface.
-
-- **Logging and Monitoring:** Access comprehensive logs of function executions, including inputs, outputs, and execution times.
-
-- **Trigger Management:** Set up triggers to automate function executions based on specific events or conditions.
-
-**Accessing the Dashboard:**
-
-After running your application, navigate to `http://localhost:8080/dashboard` to access the BabyAGI dashboard.
-## Pre-loaded Functions Summary
-
-BabyAGI includes two pre-loaded function packs:
-
-1. **Default Functions (`packs/default_functions.py`):**
- - **Function Execution:** Run, add, update, or retrieve functions and versions.
- - **Key Management:** Add and retrieve secret keys.
- - **Triggers:** Add triggers to execute functions based on others.
- - **Logs:** Retrieve logs with optional filters.
-
-2. **AI Functions (`packs/ai_generator.py`):**
- - **AI Description & Embeddings:** Auto-generate descriptions and embeddings for functions.
- - **Function Selection:** Find or choose similar functions based on prompts.
-
-## Running a Self-Building Agent
-
-BabyAGI includes two experimental self-building agents, showcasing how the framework can help a self-building coding agent leverage existing functions to write new ones.
-
-### 1. `process_user_input` in the `code_writing_functions` pack
-
-This function first determines whether to use an existing function or generate new ones. If new functions are needed, it breaks them down into smaller reusable components and combines them into a final function.
+# Supported Models
-Try this:
+This script works with all OpenAI models, as well as Llama and its variations through Llama.cpp. Default model is **gpt-3.5-turbo**. To use a different model, specify it through LLM_MODEL or use the command line.
-~~~python
-import babyagi
+## Llama
-babyagi.add_key_wrapper('openai_api_key', os.environ['OPENAI_API_KEY'])
-babyagi.load_functions("drafts/code_writing_functions")
+Llama integration requires llama-cpp package. You will also need the Llama model weights.
-babyagi.process_user_input("Grab today's score from ESPN and email it to test@test.com")
-~~~
+- **Under no circumstances share IPFS, magnet links, or any other links to model downloads anywhere in this repository, including in issues, discussions or pull requests. They will be immediately deleted.**
-When you run this, you will see the functions being generated in the shell and new functions will be available in the dashboard once completed.
+Once you have them, set LLAMA_MODEL_PATH to the path of the specific model to use. For convenience, you can link `models` in BabyAGI repo to the folder where you have the Llama model weights. Then run the script with `LLM_MODEL=llama` or `-l` argument.
-### 2. `self_build` in the `self_build` pack
+# Warning
-This function takes a user description and generates X distinct tasks that a user might ask an AI assistant. Each task is processed by `process_user_input`, creating new functions if no existing ones suffice.
+This script is designed to be run continuously as part of a task management system. Running this script continuously can result in high API usage, so please use it responsibly. Additionally, the script requires the OpenAI API to be set up correctly, so make sure you have set up the API before running the script.
-Try this:
+# Contribution
-~~~python
-import babyagi
+Needless to say, BabyAGI is still in its infancy and thus we are still determining its direction and the steps to get there. Currently, a key design goal for BabyAGI is to be _simple_ such that it's easy to understand and build upon. To maintain this simplicity, we kindly request that you adhere to the following guidelines when submitting PRs:
-babyagi.add_key_wrapper('openai_api_key', os.environ['OPENAI_API_KEY'])
-babyagi.load_functions("drafts/code_writing_functions")
-babyagi.load_functions("drafts/self_build")
+- Focus on small, modular modifications rather than extensive refactoring.
+- When introducing new features, provide a detailed description of the specific use case you are addressing.
-babyagi.self_build("A sales person at an enterprise SaaS company.", 3)
-~~~
+A note from @yoheinakajima (Apr 5th, 2023):
-This will generate 3 distinct tasks a salesperson might ask an AI assistant and create functions to handle those.
+> I know there are a growing number of PRs, appreciate your patience - as I am both new to GitHub/OpenSource, and did not plan my time availability accordingly this week. Re:direction, I've been torn on keeping it simple vs expanding - currently leaning towards keeping a core Baby AGI simple, and using this as a platform to support and promote different approaches to expanding this (eg. BabyAGIxLangchain as one direction). I believe there are various opinionated approaches that are worth exploring, and I see value in having a central place to compare and discuss. More updates coming shortly.
-*The functions will be generated and stored in the dashboard, but note that the generated code is minimal and may need improvement.
+I am new to GitHub and open source, so please be patient as I learn to manage this project properly. I run a VC firm by day, so I will generally be checking PRs and issues at night after I get my kids down - which may not be every night. Open to the idea of bringing in support, will be updating this section soon (expectations, visions, etc). Talking to lots of people and learning - hang tight for updates!
-
+# BabyAGI Activity Report
+To help the BabyAGI community stay informed about the project's progress, Blueprint AI has developed a Github activity summarizer for BabyAGI. This concise report displays a summary of all contributions to the BabyAGI repository over the past 7 days (continuously updated), making it easy for you to keep track of the latest developments.
+To view the BabyAGI 7-day activity report, go here: [https://app.blueprint.ai/github/yoheinakajima/babyagi](https://app.blueprint.ai/github/yoheinakajima/babyagi)
-**Warning:** These draft features are experimental concepts and may not function as intended. They require significant improvements and should be used with caution.
+[](https://app.blueprint.ai/github/yoheinakajima/babyagi)
-## Contributing
+# Inspired projects
-Contributions are greatly appreciatedly, but candidly I have not been great at managing PRs. Please be patient as things will move slow while I am working on this alone (on nights and weekends). I may start by building a small core crew before collaborating with a larger group.
+In the short time since it was release, BabyAGI inspired many projects. You can see them all [here](docs/inspired-projects.md).
-If you are a dev, investor, friend of open-source and interesting supporting AI work I do, please fill [this form]([https://](https://forms.gle/UZLyT75HQULr8XNUA)) (I have a few fun initiatives coming up!)
+# Backstory
-## License
+BabyAGI is a pared-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) shared on Twitter. This version is down to 140 lines: 13 comments, 22 blanks, and 105 code. The name of the repo came up in the reaction to the original autonomous agent - the author does not mean to imply that this is AGI.
-BabyAGI is released under the MIT License. See the [LICENSE](LICENSE) file for more details.
+Made with love by [@yoheinakajima](https://twitter.com/yoheinakajima), who happens to be a VC (would love to see what you're building!)
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 00000000..8daa2467
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1,14 @@
+title: BabyAGI
+email:
+description: >-
+ BabyAGI is an AI-powered task management system that uses OpenAI and Pinecone APIs to create, prioritize, and execute tasks.
+baseurl: ""
+url: "https://babyagi.org"
+logo: docs/babyagi.png
+twitter_username: babyagi_
+github_username: yoheinakajima
+show_downloads: false
+remote_theme: pages-themes/minimal@v0.2.0
+include: [docs]
+plugins:
+- jekyll-remote-theme
diff --git a/babyagi.py b/babyagi.py
new file mode 100755
index 00000000..2650e412
--- /dev/null
+++ b/babyagi.py
@@ -0,0 +1,609 @@
+#!/usr/bin/env python3
+from dotenv import load_dotenv
+
+# Load default environment variables (.env)
+load_dotenv()
+
+import os
+import time
+import logging
+from collections import deque
+from typing import Dict, List
+import importlib
+import openai
+import chromadb
+import tiktoken as tiktoken
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
+import re
+
+# default opt out of chromadb telemetry.
+from chromadb.config import Settings
+
+client = chromadb.Client(Settings(anonymized_telemetry=False))
+
+# Engine configuration
+
+# Model: GPT, LLAMA, HUMAN, etc.
+LLM_MODEL = os.getenv("LLM_MODEL", os.getenv("OPENAI_API_MODEL", "gpt-3.5-turbo")).lower()
+
+# API Keys
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+if not (LLM_MODEL.startswith("llama") or LLM_MODEL.startswith("human")):
+ assert OPENAI_API_KEY, "\033[91m\033[1m" + "OPENAI_API_KEY environment variable is missing from .env" + "\033[0m\033[0m"
+
+# Table config
+RESULTS_STORE_NAME = os.getenv("RESULTS_STORE_NAME", os.getenv("TABLE_NAME", ""))
+assert RESULTS_STORE_NAME, "\033[91m\033[1m" + "RESULTS_STORE_NAME environment variable is missing from .env" + "\033[0m\033[0m"
+
+# Run configuration
+INSTANCE_NAME = os.getenv("INSTANCE_NAME", os.getenv("BABY_NAME", "BabyAGI"))
+COOPERATIVE_MODE = "none"
+JOIN_EXISTING_OBJECTIVE = False
+
+# Goal configuration
+OBJECTIVE = os.getenv("OBJECTIVE", "")
+INITIAL_TASK = os.getenv("INITIAL_TASK", os.getenv("FIRST_TASK", ""))
+
+# Model configuration
+OPENAI_TEMPERATURE = float(os.getenv("OPENAI_TEMPERATURE", 0.0))
+
+
+# Extensions support begin
+
+def can_import(module_name):
+ try:
+ importlib.import_module(module_name)
+ return True
+ except ImportError:
+ return False
+
+
+DOTENV_EXTENSIONS = os.getenv("DOTENV_EXTENSIONS", "").split(" ")
+
+# Command line arguments extension
+# Can override any of the above environment variables
+ENABLE_COMMAND_LINE_ARGS = (
+ os.getenv("ENABLE_COMMAND_LINE_ARGS", "false").lower() == "true"
+)
+if ENABLE_COMMAND_LINE_ARGS:
+ if can_import("extensions.argparseext"):
+ from extensions.argparseext import parse_arguments
+
+ OBJECTIVE, INITIAL_TASK, LLM_MODEL, DOTENV_EXTENSIONS, INSTANCE_NAME, COOPERATIVE_MODE, JOIN_EXISTING_OBJECTIVE = parse_arguments()
+
+# Human mode extension
+# Gives human input to babyagi
+if LLM_MODEL.startswith("human"):
+ if can_import("extensions.human_mode"):
+ from extensions.human_mode import user_input_await
+
+# Load additional environment variables for enabled extensions
+# TODO: This might override the following command line arguments as well:
+# OBJECTIVE, INITIAL_TASK, LLM_MODEL, INSTANCE_NAME, COOPERATIVE_MODE, JOIN_EXISTING_OBJECTIVE
+if DOTENV_EXTENSIONS:
+ if can_import("extensions.dotenvext"):
+ from extensions.dotenvext import load_dotenv_extensions
+
+ load_dotenv_extensions(DOTENV_EXTENSIONS)
+
+# TODO: There's still work to be done here to enable people to get
+# defaults from dotenv extensions, but also provide command line
+# arguments to override them
+
+# Extensions support end
+
+print("\033[95m\033[1m" + "\n*****CONFIGURATION*****\n" + "\033[0m\033[0m")
+print(f"Name : {INSTANCE_NAME}")
+print(f"Mode : {'alone' if COOPERATIVE_MODE in ['n', 'none'] else 'local' if COOPERATIVE_MODE in ['l', 'local'] else 'distributed' if COOPERATIVE_MODE in ['d', 'distributed'] else 'undefined'}")
+print(f"LLM : {LLM_MODEL}")
+
+
+# Check if we know what we are doing
+assert OBJECTIVE, "\033[91m\033[1m" + "OBJECTIVE environment variable is missing from .env" + "\033[0m\033[0m"
+assert INITIAL_TASK, "\033[91m\033[1m" + "INITIAL_TASK environment variable is missing from .env" + "\033[0m\033[0m"
+
+LLAMA_MODEL_PATH = os.getenv("LLAMA_MODEL_PATH", "models/llama-13B/ggml-model.bin")
+if LLM_MODEL.startswith("llama"):
+ if can_import("llama_cpp"):
+ from llama_cpp import Llama
+
+ print(f"LLAMA : {LLAMA_MODEL_PATH}" + "\n")
+ assert os.path.exists(LLAMA_MODEL_PATH), "\033[91m\033[1m" + f"Model can't be found." + "\033[0m\033[0m"
+
+ CTX_MAX = 1024
+ LLAMA_THREADS_NUM = int(os.getenv("LLAMA_THREADS_NUM", 8))
+
+ print('Initialize model for evaluation')
+ llm = Llama(
+ model_path=LLAMA_MODEL_PATH,
+ n_ctx=CTX_MAX,
+ n_threads=LLAMA_THREADS_NUM,
+ n_batch=512,
+ use_mlock=False,
+ )
+
+ print('\nInitialize model for embedding')
+ llm_embed = Llama(
+ model_path=LLAMA_MODEL_PATH,
+ n_ctx=CTX_MAX,
+ n_threads=LLAMA_THREADS_NUM,
+ n_batch=512,
+ embedding=True,
+ use_mlock=False,
+ )
+
+ print(
+ "\033[91m\033[1m"
+ + "\n*****USING LLAMA.CPP. POTENTIALLY SLOW.*****"
+ + "\033[0m\033[0m"
+ )
+ else:
+ print(
+ "\033[91m\033[1m"
+ + "\nLlama LLM requires package llama-cpp. Falling back to GPT-3.5-turbo."
+ + "\033[0m\033[0m"
+ )
+ LLM_MODEL = "gpt-3.5-turbo"
+
+if LLM_MODEL.startswith("gpt-4"):
+ print(
+ "\033[91m\033[1m"
+ + "\n*****USING GPT-4. POTENTIALLY EXPENSIVE. MONITOR YOUR COSTS*****"
+ + "\033[0m\033[0m"
+ )
+
+if LLM_MODEL.startswith("human"):
+ print(
+ "\033[91m\033[1m"
+ + "\n*****USING HUMAN INPUT*****"
+ + "\033[0m\033[0m"
+ )
+
+print("\033[94m\033[1m" + "\n*****OBJECTIVE*****\n" + "\033[0m\033[0m")
+print(f"{OBJECTIVE}")
+
+if not JOIN_EXISTING_OBJECTIVE:
+ print("\033[93m\033[1m" + "\nInitial task:" + "\033[0m\033[0m" + f" {INITIAL_TASK}")
+else:
+ print("\033[93m\033[1m" + f"\nJoining to help the objective" + "\033[0m\033[0m")
+
+# Configure OpenAI
+openai.api_key = OPENAI_API_KEY
+
+
+# Llama embedding function
+class LlamaEmbeddingFunction(EmbeddingFunction):
+ def __init__(self):
+ return
+
+
+ def __call__(self, texts: Documents) -> Embeddings:
+ embeddings = []
+ for t in texts:
+ e = llm_embed.embed(t)
+ embeddings.append(e)
+ return embeddings
+
+
+# Results storage using local ChromaDB
+class DefaultResultsStorage:
+ def __init__(self):
+ logging.getLogger('chromadb').setLevel(logging.ERROR)
+ # Create Chroma collection
+ chroma_persist_dir = "chroma"
+ chroma_client = chromadb.PersistentClient(
+ settings=chromadb.config.Settings(
+ persist_directory=chroma_persist_dir,
+ )
+ )
+
+ metric = "cosine"
+ if LLM_MODEL.startswith("llama"):
+ embedding_function = LlamaEmbeddingFunction()
+ else:
+ embedding_function = OpenAIEmbeddingFunction(api_key=OPENAI_API_KEY)
+ self.collection = chroma_client.get_or_create_collection(
+ name=RESULTS_STORE_NAME,
+ metadata={"hnsw:space": metric},
+ embedding_function=embedding_function,
+ )
+
+ def add(self, task: Dict, result: str, result_id: str):
+
+ # Break the function if LLM_MODEL starts with "human" (case-insensitive)
+ if LLM_MODEL.startswith("human"):
+ return
+ # Continue with the rest of the function
+
+ embeddings = llm_embed.embed(result) if LLM_MODEL.startswith("llama") else None
+ if (
+ len(self.collection.get(ids=[result_id], include=[])["ids"]) > 0
+ ): # Check if the result already exists
+ self.collection.update(
+ ids=result_id,
+ embeddings=embeddings,
+ documents=result,
+ metadatas={"task": task["task_name"], "result": result},
+ )
+ else:
+ self.collection.add(
+ ids=result_id,
+ embeddings=embeddings,
+ documents=result,
+ metadatas={"task": task["task_name"], "result": result},
+ )
+
+ def query(self, query: str, top_results_num: int) -> List[dict]:
+ count: int = self.collection.count()
+ if count == 0:
+ return []
+ results = self.collection.query(
+ query_texts=query,
+ n_results=min(top_results_num, count),
+ include=["metadatas"]
+ )
+ return [item["task"] for item in results["metadatas"][0]]
+
+
+# Initialize results storage
+def try_weaviate():
+ WEAVIATE_URL = os.getenv("WEAVIATE_URL", "")
+ WEAVIATE_USE_EMBEDDED = os.getenv("WEAVIATE_USE_EMBEDDED", "False").lower() == "true"
+ if (WEAVIATE_URL or WEAVIATE_USE_EMBEDDED) and can_import("extensions.weaviate_storage"):
+ WEAVIATE_API_KEY = os.getenv("WEAVIATE_API_KEY", "")
+ from extensions.weaviate_storage import WeaviateResultsStorage
+ print("\nUsing results storage: " + "\033[93m\033[1m" + "Weaviate" + "\033[0m\033[0m")
+ return WeaviateResultsStorage(OPENAI_API_KEY, WEAVIATE_URL, WEAVIATE_API_KEY, WEAVIATE_USE_EMBEDDED, LLM_MODEL, LLAMA_MODEL_PATH, RESULTS_STORE_NAME, OBJECTIVE)
+ return None
+
+def try_pinecone():
+ PINECONE_API_KEY = os.getenv("PINECONE_API_KEY", "")
+ if PINECONE_API_KEY and can_import("extensions.pinecone_storage"):
+ PINECONE_ENVIRONMENT = os.getenv("PINECONE_ENVIRONMENT", "")
+ assert (
+ PINECONE_ENVIRONMENT
+ ), "\033[91m\033[1m" + "PINECONE_ENVIRONMENT environment variable is missing from .env" + "\033[0m\033[0m"
+ from extensions.pinecone_storage import PineconeResultsStorage
+ print("\nUsing results storage: " + "\033[93m\033[1m" + "Pinecone" + "\033[0m\033[0m")
+ return PineconeResultsStorage(OPENAI_API_KEY, PINECONE_API_KEY, PINECONE_ENVIRONMENT, LLM_MODEL, LLAMA_MODEL_PATH, RESULTS_STORE_NAME, OBJECTIVE)
+ return None
+
+def use_chroma():
+ print("\nUsing results storage: " + "\033[93m\033[1m" + "Chroma (Default)" + "\033[0m\033[0m")
+ return DefaultResultsStorage()
+
+results_storage = try_weaviate() or try_pinecone() or use_chroma()
+
+# Task storage supporting only a single instance of BabyAGI
+class SingleTaskListStorage:
+ def __init__(self):
+ self.tasks = deque([])
+ self.task_id_counter = 0
+
+ def append(self, task: Dict):
+ self.tasks.append(task)
+
+ def replace(self, tasks: List[Dict]):
+ self.tasks = deque(tasks)
+
+ def popleft(self):
+ return self.tasks.popleft()
+
+ def is_empty(self):
+ return False if self.tasks else True
+
+ def next_task_id(self):
+ self.task_id_counter += 1
+ return self.task_id_counter
+
+ def get_task_names(self):
+ return [t["task_name"] for t in self.tasks]
+
+
+# Initialize tasks storage
+tasks_storage = SingleTaskListStorage()
+if COOPERATIVE_MODE in ['l', 'local']:
+ if can_import("extensions.ray_tasks"):
+ import sys
+ from pathlib import Path
+
+ sys.path.append(str(Path(__file__).resolve().parent))
+ from extensions.ray_tasks import CooperativeTaskListStorage
+
+ tasks_storage = CooperativeTaskListStorage(OBJECTIVE)
+ print("\nReplacing tasks storage: " + "\033[93m\033[1m" + "Ray" + "\033[0m\033[0m")
+elif COOPERATIVE_MODE in ['d', 'distributed']:
+ pass
+
+
+def limit_tokens_from_string(string: str, model: str, limit: int) -> str:
+ """Limits the string to a number of tokens (estimated)."""
+
+ try:
+ encoding = tiktoken.encoding_for_model(model)
+ except:
+ encoding = tiktoken.encoding_for_model('gpt2') # Fallback for others.
+
+ encoded = encoding.encode(string)
+
+ return encoding.decode(encoded[:limit])
+
+
+def openai_call(
+ prompt: str,
+ model: str = LLM_MODEL,
+ temperature: float = OPENAI_TEMPERATURE,
+ max_tokens: int = 100,
+):
+ while True:
+ try:
+ if model.lower().startswith("llama"):
+ result = llm(prompt[:CTX_MAX],
+ stop=["### Human"],
+ echo=False,
+ temperature=0.2,
+ top_k=40,
+ top_p=0.95,
+ repeat_penalty=1.05,
+ max_tokens=200)
+ # print('\n*****RESULT JSON DUMP*****\n')
+ # print(json.dumps(result))
+ # print('\n')
+ return result['choices'][0]['text'].strip()
+ elif model.lower().startswith("human"):
+ return user_input_await(prompt)
+ elif not model.lower().startswith("gpt-"):
+ # Use completion API
+ response = openai.Completion.create(
+ engine=model,
+ prompt=prompt,
+ temperature=temperature,
+ max_tokens=max_tokens,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0,
+ )
+ return response.choices[0].text.strip()
+ else:
+ # Use 4000 instead of the real limit (4097) to give a bit of wiggle room for the encoding of roles.
+ # TODO: different limits for different models.
+
+ trimmed_prompt = limit_tokens_from_string(prompt, model, 4000 - max_tokens)
+
+ # Use chat completion API
+ messages = [{"role": "system", "content": trimmed_prompt}]
+ response = openai.ChatCompletion.create(
+ model=model,
+ messages=messages,
+ temperature=temperature,
+ max_tokens=max_tokens,
+ n=1,
+ stop=None,
+ )
+ return response.choices[0].message.content.strip()
+ except openai.error.RateLimitError:
+ print(
+ " *** The OpenAI API rate limit has been exceeded. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.Timeout:
+ print(
+ " *** OpenAI API timeout occurred. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.APIError:
+ print(
+ " *** OpenAI API error occurred. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.APIConnectionError:
+ print(
+ " *** OpenAI API connection error occurred. Check your network settings, proxy configuration, SSL certificates, or firewall rules. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.InvalidRequestError:
+ print(
+ " *** OpenAI API invalid request. Check the documentation for the specific API method you are calling and make sure you are sending valid and complete parameters. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.ServiceUnavailableError:
+ print(
+ " *** OpenAI API service unavailable. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ else:
+ break
+
+
+def task_creation_agent(
+ objective: str, result: Dict, task_description: str, task_list: List[str]
+):
+ prompt = f"""
+You are to use the result from an execution agent to create new tasks with the following objective: {objective}.
+The last completed task has the result: \n{result["data"]}
+This result was based on this task description: {task_description}.\n"""
+
+ if task_list:
+ prompt += f"These are incomplete tasks: {', '.join(task_list)}\n"
+ prompt += "Based on the result, return a list of tasks to be completed in order to meet the objective. "
+ if task_list:
+ prompt += "These new tasks must not overlap with incomplete tasks. "
+
+ prompt += """
+Return one task per line in your response. The result must be a numbered list in the format:
+
+#. First task
+#. Second task
+
+The number of each entry must be followed by a period. If your list is empty, write "There are no tasks to add at this time."
+Unless your list is empty, do not include any headers before your numbered list or follow your numbered list with any other output."""
+
+ print(f'\n*****TASK CREATION AGENT PROMPT****\n{prompt}\n')
+ response = openai_call(prompt, max_tokens=2000)
+ print(f'\n****TASK CREATION AGENT RESPONSE****\n{response}\n')
+ new_tasks = response.split('\n')
+ new_tasks_list = []
+ for task_string in new_tasks:
+ task_parts = task_string.strip().split(".", 1)
+ if len(task_parts) == 2:
+ task_id = ''.join(s for s in task_parts[0] if s.isnumeric())
+ task_name = re.sub(r'[^\w\s_]+', '', task_parts[1]).strip()
+ if task_name.strip() and task_id.isnumeric():
+ new_tasks_list.append(task_name)
+ # print('New task created: ' + task_name)
+
+ out = [{"task_name": task_name} for task_name in new_tasks_list]
+ return out
+
+
+def prioritization_agent():
+ task_names = tasks_storage.get_task_names()
+ bullet_string = '\n'
+
+ prompt = f"""
+You are tasked with prioritizing the following tasks: {bullet_string + bullet_string.join(task_names)}
+Consider the ultimate objective of your team: {OBJECTIVE}.
+Tasks should be sorted from highest to lowest priority, where higher-priority tasks are those that act as pre-requisites or are more essential for meeting the objective.
+Do not remove any tasks. Return the ranked tasks as a numbered list in the format:
+
+#. First task
+#. Second task
+
+The entries must be consecutively numbered, starting with 1. The number of each entry must be followed by a period.
+Do not include any headers before your ranked list or follow your list with any other output."""
+
+ print(f'\n****TASK PRIORITIZATION AGENT PROMPT****\n{prompt}\n')
+ response = openai_call(prompt, max_tokens=2000)
+ print(f'\n****TASK PRIORITIZATION AGENT RESPONSE****\n{response}\n')
+ if not response:
+ print('Received empty response from priotritization agent. Keeping task list unchanged.')
+ return
+ new_tasks = response.split("\n") if "\n" in response else [response]
+ new_tasks_list = []
+ for task_string in new_tasks:
+ task_parts = task_string.strip().split(".", 1)
+ if len(task_parts) == 2:
+ task_id = ''.join(s for s in task_parts[0] if s.isnumeric())
+ task_name = re.sub(r'[^\w\s_]+', '', task_parts[1]).strip()
+ if task_name.strip():
+ new_tasks_list.append({"task_id": task_id, "task_name": task_name})
+
+ return new_tasks_list
+
+
+# Execute a task based on the objective and five previous tasks
+def execution_agent(objective: str, task: str) -> str:
+ """
+ Executes a task based on the given objective and previous context.
+
+ Args:
+ objective (str): The objective or goal for the AI to perform the task.
+ task (str): The task to be executed by the AI.
+
+ Returns:
+ str: The response generated by the AI for the given task.
+
+ """
+
+ context = context_agent(query=objective, top_results_num=5)
+ # print("\n****RELEVANT CONTEXT****\n")
+ # print(context)
+ # print('')
+ prompt = f'Perform one task based on the following objective: {objective}.\n'
+ if context:
+ prompt += 'Take into account these previously completed tasks:' + '\n'.join(context)
+ prompt += f'\nYour task: {task}\nResponse:'
+ return openai_call(prompt, max_tokens=2000)
+
+
+# Get the top n completed tasks for the objective
+def context_agent(query: str, top_results_num: int):
+ """
+ Retrieves context for a given query from an index of tasks.
+
+ Args:
+ query (str): The query or objective for retrieving context.
+ top_results_num (int): The number of top results to retrieve.
+
+ Returns:
+ list: A list of tasks as context for the given query, sorted by relevance.
+
+ """
+ results = results_storage.query(query=query, top_results_num=top_results_num)
+ # print("****RESULTS****")
+ # print(results)
+ return results
+
+
+# Add the initial task if starting new objective
+if not JOIN_EXISTING_OBJECTIVE:
+ initial_task = {
+ "task_id": tasks_storage.next_task_id(),
+ "task_name": INITIAL_TASK
+ }
+ tasks_storage.append(initial_task)
+
+
+def main():
+ loop = True
+ while loop:
+ # As long as there are tasks in the storage...
+ if not tasks_storage.is_empty():
+ # Print the task list
+ print("\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m\033[0m")
+ for t in tasks_storage.get_task_names():
+ print(" • " + str(t))
+
+ # Step 1: Pull the first incomplete task
+ task = tasks_storage.popleft()
+ print("\033[92m\033[1m" + "\n*****NEXT TASK*****\n" + "\033[0m\033[0m")
+ print(str(task["task_name"]))
+
+ # Send to execution function to complete the task based on the context
+ result = execution_agent(OBJECTIVE, str(task["task_name"]))
+ print("\033[93m\033[1m" + "\n*****TASK RESULT*****\n" + "\033[0m\033[0m")
+ print(result)
+
+ # Step 2: Enrich result and store in the results storage
+ # This is where you should enrich the result if needed
+ enriched_result = {
+ "data": result
+ }
+ # extract the actual result from the dictionary
+ # since we don't do enrichment currently
+ # vector = enriched_result["data"]
+
+ result_id = f"result_{task['task_id']}"
+
+ results_storage.add(task, result, result_id)
+
+ # Step 3: Create new tasks and re-prioritize task list
+ # only the main instance in cooperative mode does that
+ new_tasks = task_creation_agent(
+ OBJECTIVE,
+ enriched_result,
+ task["task_name"],
+ tasks_storage.get_task_names(),
+ )
+
+ print('Adding new tasks to task_storage')
+ for new_task in new_tasks:
+ new_task.update({"task_id": tasks_storage.next_task_id()})
+ print(str(new_task))
+ tasks_storage.append(new_task)
+
+ if not JOIN_EXISTING_OBJECTIVE:
+ prioritized_tasks = prioritization_agent()
+ if prioritized_tasks:
+ tasks_storage.replace(prioritized_tasks)
+
+ # Sleep a bit before checking the task list again
+ time.sleep(5)
+ else:
+ print('Done.')
+ loop = False
+
+
+if __name__ == "__main__":
+ main()
diff --git a/babyagi/__init__.py b/babyagi/__init__.py
deleted file mode 100644
index 84cfbc99..00000000
--- a/babyagi/__init__.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# babyagi/__init__.py
-
-from flask import Flask, g
-from .functionz.core.framework import Functionz
-from .dashboard import create_dashboard
-from .api import create_api_blueprint
-import os
-import importlib.util
-import traceback
-import sys
-
-# Singleton instance of the functionz framework
-_func_instance = Functionz()
-
-
-def get_func_instance():
- return _func_instance
-
-def create_app(dashboard_route='/dashboard'):
- app = Flask(__name__)
-
- # Remove leading slash if present to avoid double slashes
- if dashboard_route.startswith('/'):
- dashboard_route = dashboard_route[1:]
-
- # Create and register the dashboard blueprint with dashboard_route
- dashboard_blueprint = create_dashboard(_func_instance, dashboard_route)
-
- # Create and register the API blueprint
- api_blueprint = create_api_blueprint()
-
- # Register the blueprints
- app.register_blueprint(dashboard_blueprint, url_prefix=f'/{dashboard_route}')
- app.register_blueprint(api_blueprint) # Mounted at '/api' as defined in the blueprint
-
- # Store the dashboard route for use in templates
- app.config['DASHBOARD_ROUTE'] = dashboard_route
-
- # Ensure the Functionz instance is accessible in the request context
- @app.before_request
- def set_functionz():
- g.functionz = _func_instance
- g.dashboard_route = dashboard_route # Optional, if needed globally
-
- return app
-
-# Function to register functions using the babyagi framework
-def register_function(*args, **kwargs):
- def wrapper(func):
- try:
- _func_instance.register_function(*args, **kwargs)(func)
- setattr(sys.modules[__name__], func.__name__, func)
- #print(f"Function '{func.__name__}' registered successfully.")
- except Exception as e:
- print(f"Error registering function '{func.__name__}': {e}")
- traceback.print_exc()
- return func
- return wrapper
-
-# Function to load additional function packs
-def load_functions(pack_name_or_path):
- #print(f"Attempting to load function pack: {pack_name_or_path}")
- if os.path.exists(pack_name_or_path):
- try:
- spec = importlib.util.spec_from_file_location("custom_pack", pack_name_or_path)
- module = importlib.util.module_from_spec(spec)
- spec.loader.exec_module(module)
- #print(f"Custom pack loaded from {pack_name_or_path}")
- except Exception as e:
- #print(f"Failed to load custom pack from path '{pack_name_or_path}': {e}")
- traceback.print_exc()
- else:
- try:
- print(f"Assuming '{pack_name_or_path}' is an internal pack...")
- _func_instance.load_function_pack(pack_name_or_path)
- print(f"Internal pack '{pack_name_or_path}' loaded successfully.")
- except Exception as e:
- print(f"Failed to load internal pack '{pack_name_or_path}': {e}")
- traceback.print_exc()
-
-
-def use_blueprints(app, dashboard_route='/dashboard'):
- """
- Registers the babyagi blueprints with the provided Flask app.
-
- Args:
- app (Flask): The Flask application instance.
- dashboard_route (str): The route prefix for the dashboard.
- """
- # Remove leading slash if present
- if dashboard_route.startswith('/'):
- dashboard_route = dashboard_route[1:]
-
- # Create blueprints
- dashboard_blueprint = create_dashboard(_func_instance, dashboard_route)
- api_blueprint = create_api_blueprint()
-
- # Register blueprints
- app.register_blueprint(dashboard_blueprint, url_prefix=f'/{dashboard_route}')
- app.register_blueprint(api_blueprint) # Mounted at '/api' as defined in the blueprint
-
- # Store the dashboard route for use in templates
- app.config['DASHBOARD_ROUTE'] = dashboard_route
-
- # Ensure the Functionz instance is accessible in the request context
- @app.before_request
- def set_functionz():
- g.functionz = _func_instance
- g.dashboard_route = dashboard_route # Optional, if needed globally
-
-
-def __getattr__(name):
- """
- Dynamic attribute access for the babyagi module.
- If a function with the given name exists in the database,
- return a callable that executes the function via the executor.
- """
- try:
- if _func_instance.get_function(name):
- # Return a callable that executes the function via the executor
- return lambda *args, **kwargs: _func_instance.executor.execute(name, *args, **kwargs)
- except Exception as e:
- pass
- raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-# Auto-load default function packs when babyagi is imported
-try:
- print("Attempting to load default function packs...")
- # Uncomment if needed
- _func_instance.load_function_pack('default/default_functions')
- _func_instance.load_function_pack('default/ai_functions')
- _func_instance.load_function_pack('default/os')
- _func_instance.load_function_pack('default/function_calling_chat')
-except Exception as e:
- print(f"Error loading default function packs: {e}")
- traceback.print_exc()
-
-print("babyagi/__init__.py loaded")
diff --git a/babyagi/api/__init__.py b/babyagi/api/__init__.py
deleted file mode 100644
index 2ae48f35..00000000
--- a/babyagi/api/__init__.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# babyagi/api/__init__.py
-
-from flask import Blueprint, jsonify, request, g
-from datetime import datetime
-from io import StringIO
-import logging
-import os
-import sys
-import importlib.util
-
-logger = logging.getLogger(__name__)
-
-def create_api_blueprint():
- api = Blueprint('api', __name__, url_prefix='/api')
-
- # Removed the before_request function since g.functionz is set in the main app
-
- @api.route('/functions')
- def get_functions():
- logger.debug("Accessing /api/functions route.")
- try:
- functions = g.functionz.get_all_functions()
- logger.debug(f"Retrieved {len(functions)} functions.")
- return jsonify(functions)
- except Exception as e:
- logger.error(f"Error in get_functions: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/function/')
- def get_function(function_name):
- logger.debug(f"Accessing /api/function/{function_name} route.")
- try:
- function = g.functionz.db.get_function(function_name)
- if not function:
- logger.warning(f"Function '{function_name}' not found.")
- return jsonify({"error": f"Function '{function_name}' not found."}), 404
- return jsonify(function)
- except Exception as e:
- logger.error(f"Error getting function {function_name}: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/function/', methods=['PUT'])
- def update_function(function_name):
- logger.debug(f"Accessing /api/function/{function_name} [PUT] route.")
- try:
- data = request.get_json()
- if not data or 'code' not in data:
- logger.warning("No 'code' provided in request data.")
- return jsonify({"error": "No 'code' provided in request data."}), 400
- g.functionz.update_function(function_name, code=data['code'])
- logger.info(f"Function '{function_name}' updated successfully.")
- return jsonify({"status": "success"})
- except Exception as e:
- logger.error(f"Error updating function {function_name}: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/execute/', methods=['POST'])
- def execute_function(function_name):
- logger.debug(f"Accessing /api/execute/{function_name} [POST] route.")
- try:
- params = request.get_json() or {}
-
- if function_name == 'execute_function_wrapper':
- # Special handling for execute_function_wrapper
- inner_function_name = params.pop('function_name', None)
- args = params.pop('args', [])
- kwargs = params.pop('kwargs', {})
- result = g.functionz.executor.execute(function_name, inner_function_name, *args, **kwargs)
- else:
- # Normal execution for other functions
- result = g.functionz.executor.execute(function_name, **params)
-
- logger.info(f"Function '{function_name}' executed successfully.")
- return jsonify(result)
- except Exception as e:
- logger.error(f"Error executing function {function_name}: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/function//versions')
- def get_function_versions(function_name):
- logger.debug(f"Accessing /api/function/{function_name}/versions route.")
- try:
- versions = g.functionz.get_function_versions(function_name)
- logger.debug(f"Retrieved {len(versions)} versions for function '{function_name}'.")
- return jsonify(versions)
- except Exception as e:
- logger.error(f"Error getting versions for function {function_name}: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/function//activate/', methods=['POST'])
- def activate_function_version(function_name, version):
- logger.debug(f"Accessing /api/function/{function_name}/activate/{version} [POST] route.")
- try:
- g.functionz.activate_function_version(function_name, int(version))
- logger.info(f"Version {version} of function '{function_name}' activated successfully.")
- return jsonify({"status": "success"})
- except ValueError:
- logger.warning(f"Invalid version number provided: {version}")
- return jsonify({"error": "Invalid version number."}), 400
- except Exception as e:
- logger.error(f"Error activating version {version} for function {function_name}: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
-
- @api.route('/logs/')
- @api.route('/logs', defaults={'function_name': None})
- def get_logs(function_name):
- logger.debug(f"Accessing /api/logs/{function_name if function_name else 'all'} route.")
- try:
- start_date_str = request.args.get('start_date')
- end_date_str = request.args.get('end_date')
- triggered_by_log_id_str = request.args.get('triggered_by_log_id') # New filter
- start_date = datetime.fromisoformat(start_date_str) if start_date_str else None
- end_date = datetime.fromisoformat(end_date_str) if end_date_str else None
- triggered_by_log_id = int(triggered_by_log_id_str) if triggered_by_log_id_str else None # Convert to int if provided
-
- logs = g.functionz.db.get_logs(function_name, start_date, end_date, triggered_by_log_id)
- if function_name:
- logger.debug(f"Retrieved {len(logs)} logs for function '{function_name}'.")
- else:
- logger.debug(f"Retrieved {len(logs)} logs for all functions.")
- return jsonify(logs)
- except ValueError:
- logger.warning("Invalid date format or triggered_by_log_id provided.")
- return jsonify({"error": "Invalid date format or triggered_by_log_id. Use ISO format for dates and integer for triggered_by_log_id."}), 400
- except Exception as e:
- logger.error(f"Error getting logs for function '{function_name}': {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/log_bundle/')
- def get_log_bundle(log_id):
- logger.debug(f"Accessing /api/log_bundle/{log_id} route.")
- try:
- logs = g.functionz.db.get_log_bundle(log_id)
- return jsonify({'logs': logs})
- except Exception as e:
- logger.error(f"Error getting log bundle for log_id '{log_id}': {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
-
- @api.route('/triggers/', methods=['GET'])
- def get_triggers(function_name):
- logger.debug(f"Accessing /api/triggers/{function_name} [GET] route.")
- try:
- triggers = g.functionz.get_triggers_for_function(function_name)
- trigger_list = [
- getattr(trigger.triggering_function, 'name', 'any function')
- for trigger in triggers
- ]
- logger.debug(f"Retrieved {len(trigger_list)} triggers for function '{function_name}'.")
- return jsonify(trigger_list)
- except Exception as e:
- logger.error(f"Error getting triggers for function {function_name}: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
-
- logger.info("API blueprint created successfully.")
- return api
diff --git a/babyagi/dashboard/__init__.py b/babyagi/dashboard/__init__.py
deleted file mode 100644
index f7999f03..00000000
--- a/babyagi/dashboard/__init__.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# babyagi/dashboard/__init__.py
-
-from flask import Blueprint, render_template, g, send_from_directory
-import logging
-import os
-
-logger = logging.getLogger(__name__)
-
-def create_dashboard(func_instance, dashboard_route):
- if func_instance is None:
- raise ValueError("func_instance cannot be None")
- if dashboard_route is None:
- raise ValueError("dashboard_route cannot be None")
-
- dashboard = Blueprint('dashboard', __name__,
- template_folder='templates',
- static_folder='static',
- static_url_path='/dashboard/static')
-
- logger.info("Creating dashboard blueprint...")
-
- @dashboard.before_request
- def before_request():
- """Set up the necessary context before each request."""
- g.functionz = func_instance
- g.dashboard_route = dashboard_route
- logger.debug("Set g.functionz and g.dashboard_route for the request context.")
-
- @dashboard.route('/')
- def dashboard_home():
- logger.info("Accessing dashboard home page.")
- try:
- logger.debug(f"Dashboard Route: {g.dashboard_route}")
- return render_template('index.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in dashboard_home: {str(e)}", exc_info=True)
- return f"Error loading dashboard: {str(e)}", 500
-
- @dashboard.route('/function/')
- def function_detail(function_name):
- logger.info(f"Accessing function detail for: {function_name}")
- try:
- function = g.functionz.db.get_function(function_name)
- if not function:
- logger.warning(f"Function '{function_name}' not found.")
- return f"Function '{function_name}' not found.", 404
- return render_template('function_details.html', function_name=function_name, dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in function_detail: {str(e)}", exc_info=True)
- return f"Error loading function detail: {str(e)}", 500
-
- @dashboard.route('/graph')
- def function_graph():
- logger.info("Accessing function relationship graph page.")
- try:
- return render_template('function_graph.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in function_graph: {str(e)}", exc_info=True)
- return f"Error loading function graph: {str(e)}", 500
-
- @dashboard.route('/mermaid')
- def function_graph_mermaid():
- logger.info("Accessing mermaid function relationship graph page.")
- try:
- return render_template('function_graph_mermaid.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in function_graph_mermaid: {str(e)}", exc_info=True)
- return f"Error loading mermaid function graph: {str(e)}", 500
-
- @dashboard.route('/3d')
- def function_graph_3d():
- logger.info("Accessing 3D function relationship graph page.")
- try:
- return render_template('function_graph_3d.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in function_graph_3d: {str(e)}", exc_info=True)
- return f"Error loading 3D function graph: {str(e)}", 500
-
- @dashboard.route('/logs')
- def logs_dashboard():
- logger.info("Accessing logs dashboard.")
- try:
- return render_template('logs_dashboard.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in logs_dashboard: {str(e)}", exc_info=True)
- return f"Error loading logs dashboard: {str(e)}", 500
-
- @dashboard.route('/log/')
- def log_page(log_id):
- logger.info(f"Accessing log page for Log ID {log_id}.")
- try:
- return render_template(
- 'log_page.html',
- log_id=log_id,
- dashboard_route=g.dashboard_route # Pass the dashboard route if needed
- )
- except Exception as e:
- logger.error(f"Error in log_page for Log ID {log_id}: {str(e)}", exc_info=True)
- return f"Error loading log page for Log ID {log_id}: {str(e)}", 500
-
- @dashboard.route('/log_graph')
- def log_relationship_graph():
- logger.info("Accessing log relationship graph.")
- try:
- return render_template('log_relationship_graph.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in log_relationship_graph: {str(e)}", exc_info=True)
- return f"Error loading log relationship graph: {str(e)}", 500
-
- @dashboard.route('/chat')
- def chat_page():
- logger.info("Accessing chat page.")
- try:
- return render_template('chat.html', dashboard_route=g.dashboard_route)
- except Exception as e:
- logger.error(f"Error in chat_page: {str(e)}", exc_info=True)
- return f"Error loading chat page: {str(e)}", 500
-
- @dashboard.route('/')
- def serve_static_files(filename):
- """Serve static files from the dashboard's static folder."""
- logger.debug(f"Serving static file: {filename}")
- try:
- return send_from_directory(dashboard.static_folder, filename)
- except Exception as e:
- logger.error(f"Error serving static file '{filename}': {str(e)}", exc_info=True)
- return "File not found.", 404
-
- logger.info("Dashboard blueprint created successfully.")
- return dashboard
-
-logger.info("Dashboard __init__.py loaded successfully.")
diff --git a/babyagi/dashboard/static/css/style.css b/babyagi/dashboard/static/css/style.css
deleted file mode 100644
index 8c614604..00000000
--- a/babyagi/dashboard/static/css/style.css
+++ /dev/null
@@ -1,432 +0,0 @@
-/* static/css/style.css */
-
-/* Global Variables */
-:root {
- /* Color variables */
- --primary-color: #3498db;
- --secondary-color: #2c3e50;
- --background-color: #f0f4f8;
- --text-color: #333333;
- --border-color: #e0e0e0;
- --hover-color: #f8f9fa;
- --card-bg-color: #ffffff;
- --bg-color: #f0f4f8;
- --text-color: #333;
- --accent-color: #3498db;
- --hover-color: #f7fbfc;
- --card-bg: #ffffff;
-}
-
-
-
-/* Global Styles */
-body, html {
- margin: 0;
- padding: 0;
- font-family: 'Inter', Arial, sans-serif;
- background-color: var(--background-color);
- color: var(--text-color);
- font-size: 12px;
- line-height: 1.4;
-}
-
-.container {
- width: 100%;
- max-width: 100%;
- padding: 20px;
- margin: 0 auto;
- box-sizing: border-box;
-}
-
-
-.details-container {
- width: 100%;
- max-width: 1600px;
- padding: 20px;
- margin: 0 auto;
- box-sizing: border-box;
-}
-
-/* Hide elements with 'mobile-only' class on screens wider than 768px */
-@media (min-width: 768px) {
- .mobile-only {
- display: none;
- }
-}
-
-/* Hide elements with 'desktop-only' class on screens narrower than 768px */
-@media (max-width: 767px) {
- .desktop-only {
- display: none;
- }
-}
-
-
-/* Headers */
-h1 {
- color: var(--secondary-color);
- font-size: 1.5em;
- font-weight: 600;
- margin-bottom: 20px;
- text-align: left;
-}
-
-h1 small {
- font-size: 0.7em;
- font-weight: normal;
- margin-left: 10px;
-}
-
-h1 small a {
- color: var(--primary-color);
- text-decoration: none;
-}
-
-/* Navigation Menu Styles */
-nav {
- background-color: var(--secondary-color);
- padding: 10px 0;
- margin-bottom: 20px;
-}
-
-nav ul {
- list-style-type: none;
- margin: 0;
- padding: 0;
- display: flex;
- justify-content: left;
- flex-wrap: wrap;
-}
-
-nav li {
- margin: 0 15px;
-}
-
-nav a {
- color: #ffffff;
- text-decoration: none;
- font-weight: 500;
- font-size: 14px;
-}
-
-nav a:hover {
- text-decoration: underline;
- color: var(--primary-color);
-}
-
-/* Breadcrumb Styles */
-.breadcrumb {
- margin-bottom: 20px;
-}
-
-.breadcrumb a {
- color: var(--primary-color);
- text-decoration: none;
-}
-
-.breadcrumb a:hover {
- text-decoration: underline;
-}
-
-
-
-/* Search Bar Styles */
-#searchInput {
- width: 100%;
- max-width: 1200px; /* Match the container's max-width */
- padding: 10px;
- margin-bottom: 20px;
- font-size: 14px;
- border: 1px solid var(--border-color);
- border-radius: 4px;
- box-sizing: border-box;
-}
-
-/* Table Styles */
-table {
- width: 100%;
- border-collapse: separate;
- border-spacing: 0;
- background-color: var(--card-bg-color);
- box-shadow: 0 1px 3px rgba(0,0,0,0.1);
- table-layout: fixed;
-}
-
-th, td {
- padding: 12px;
- text-align: left;
- border-bottom: 1px solid var(--border-color);
- vertical-align: top;
-}
-
-td {
- word-wrap: break-word;
- overflow-wrap: break-word;
-}
-
-th {
- background-color: var(--secondary-color);
- color: white;
- font-weight: 500;
- white-space: nowrap;
- cursor: pointer;
-}
-
-th.sortable:hover {
- background-color: var(--primary-color);
-}
-
-tr:hover {
- background-color: var(--hover-color);
-}
-
-.function-name {
- color: var(--primary-color);
- font-weight: 500;
- text-decoration: none;
-}
-
-.function-name:hover {
- text-decoration: underline;
-}
-
-.function-link, .function-name {
- color: var(--primary-color);
- font-weight: 500;
- text-decoration: none;
-}
-
-.function-link:hover, .function-name:hover {
- text-decoration: underline;
-}
-
-.small-text {
- font-size: 0.92em;
- color: #666;
-}
-
-.params-list, .dependencies-list, .imports-list, .triggers-list {
- list-style-type: none;
- padding: 0;
- margin: 0;
-}
-
-.params-list li, .dependencies-list li, .imports-list, .triggers-list li {
- margin-bottom: 2px;
-}
-
-/* Card Styles (for mobile view) */
-.function-grid {
- display: none;
- grid-template-columns: 1fr;
- gap: 15px;
- padding: 10px;
-}
-
-.function-card {
- background-color: var(--background-color);
- border: 1px solid var(--border-color);
- border-radius: 4px;
- padding: 15px;
-}
-
-.function-meta {
- color: #666;
- margin-bottom: 10px;
-}
-
-.function-description {
- margin-bottom: 10px;
-}
-
-.params-title {
- font-weight: 500;
- margin-top: 8px;
- margin-bottom: 3px;
-}
-
-.log-info {
- display: flex;
- justify-content: space-between;
- color: #666;
- border-top: 1px solid var(--border-color);
- padding-top: 8px;
- margin-top: 8px;
-}
-
-/* Function Detail Page Styles */
-.function-detail {
- background-color: var(--card-bg-color);
- padding: 20px;
- border-radius: 8px;
- margin-bottom: 20px;
-}
-
-.section-title {
- font-size: 1.2em;
- font-weight: bold;
- margin-top: 20px;
- margin-bottom: 10px;
- color: var(--primary-color);
-}
-
-.button {
- background-color: var(--primary-color);
- color: white;
- padding: 10px 15px;
- border: none;
- border-radius: 4px;
- cursor: pointer;
- font-size: 14px;
- margin-right: 10px;
-}
-
-.button:hover {
- background-color: var(--hover-color);
-}
-
-#functionLogs {
- max-height:600px;
- overflow-y:scroll;
-}
-
-.log-entry, .execution-result {
- background-color: #f8f9fa;
- padding: 10px;
- margin-bottom: 10px;
- border-radius: 4px;
- font-family: monospace;
- font-size: 12px;
- line-height: 1.4;
- overflow-x: auto;
-}
-
-.param-input {
- margin-bottom: 10px;
-}
-
-.param-input label {
- display: block;
- margin-bottom: 5px;
-}
-
-.param-input input, .param-input textarea {
- width: 100%;
- padding: 5px;
- border: 1px solid var(--border-color);
- border-radius: 4px;
-}
-
-.breadcrumb {
- margin-bottom: 20px;
-}
-
-.breadcrumb a {
- color: var(--primary-color);
- text-decoration: none;
-}
-
-.breadcrumb a:hover {
- text-decoration: underline;
-}
-
-.two-column {
- display: flex;
- flex-wrap: wrap;
- gap: 20px;
-}
-
-.column {
- flex: 1;
- min-width: 300px;
-}
-
-.detail-item {
- background-color: #f8f9fa;
- padding: 10px;
- margin-bottom: 10px;
- border-radius: 4px;
- font-family: monospace;
- font-size: 12px;
- line-height: 1.4;
- overflow-x: auto;
-}
-
-.detail-label {
- display: inline-block;
- min-width: 120px;
- font-weight: bold;
- color: var(--primary-color);
- margin-right: 10px;
-}
-
-.detail-value {
- display: inline-block;
-}
-
-.detail-list {
- margin: 5px 0 5px 130px;
- padding-left: 20px;
-}
-
-.CodeMirror {
- font-size: 12px;
- border: 1px solid var(--border-color);
- border-radius: 4px;
- margin-bottom: 5px;
-}
-
-/* Version History */
-.version-item {
- padding: 10px;
- border-bottom: 1px solid #ccc;
- background-color: #f8f9fa;
- margin-bottom: 5px;
- word-wrap: break-word;
- white-space: pre-wrap;
- max-height:600px;
-}
-
-.version-item.active {
- background-color: #e0f7fa;
-}
-
-.version-item pre {
- background-color: #f1f1f1;
- padding: 10px;
- border-radius: 4px;
- font-size: 12px;
- overflow-x: auto;
- white-space: pre-wrap;
- word-wrap: break-word;
- line-height: 1.4;
-}
-
-#toggleVersionHistory {
- margin-top: 10px;
-}
-
-#versionHistory {
- margin-top: 10px;
-}
-
-/* Media Queries */
-@media (max-width: 768px) {
- /* Hide the table in mobile, show the card grid */
- table {
- display: none;
- }
- .function-grid {
- display: grid;
- }
- .two-column {
- flex-direction: column;
- }
- .container, #searchInput, .function-detail, .column, input, body {
- padding: 10px;
- max-width: 100%;
- }
- .param-input{
- margin:10px;
- }
-}
\ No newline at end of file
diff --git a/babyagi/dashboard/static/js/dashboard.js b/babyagi/dashboard/static/js/dashboard.js
deleted file mode 100644
index 14b08553..00000000
--- a/babyagi/dashboard/static/js/dashboard.js
+++ /dev/null
@@ -1,203 +0,0 @@
-/* static/js/dashboard.js */
-
-// Assume that dashboardRoute, apiFunctionsUrl, and apiLogsUrl are defined in the HTML template
-
-let currentSort = { key: null, direction: 'asc' };
-let allFunctions = []; // This will hold the functions data globally
-
-function filterTable() {
- const input = document.getElementById("searchInput").value.toLowerCase();
- const table = document.getElementById("functionTable");
- const rows = table.getElementsByTagName("tr");
- const grid = document.getElementById("functionGrid");
- const cards = grid.getElementsByClassName("function-card");
-
- for (let i = 1; i < rows.length; i++) { // Start at 1 to skip header row
- let match = false;
- const cells = rows[i].getElementsByTagName("td");
- for (let j = 0; j < cells.length; j++) {
- if (cells[j].innerText.toLowerCase().includes(input)) {
- match = true;
- break;
- }
- }
- rows[i].style.display = match ? "" : "none";
- }
-
- // Filter cards for mobile view
- for (let i = 0; i < cards.length; i++) {
- if (cards[i].innerText.toLowerCase().includes(input)) {
- cards[i].style.display = "";
- } else {
- cards[i].style.display = "none";
- }
- }
-}
-function sortTable(key) {
- const direction = currentSort.key === key && currentSort.direction === 'asc' ? 'desc' : 'asc';
- currentSort = { key, direction };
-
- const sortedFunctions = [...allFunctions].sort((a, b) => {
- let valA, valB;
- if (key === 'name') {
- valA = a.name.toLowerCase();
- valB = b.name.toLowerCase();
- } else if (key === 'created_date') {
- valA = new Date(a.created_date);
- valB = new Date(b.created_date);
- } else if (key === 'total_logs') {
- valA = a.total_logs || 0;
- valB = b.total_logs || 0;
- } else if (key === 'last_log_date') {
- valA = new Date(a.last_log_date || 0);
- valB = new Date(b.last_log_date || 0);
- }
-
- if (direction === 'asc') return valA > valB ? 1 : -1;
- return valA < valB ? 1 : -1;
- });
-
- populateDashboard(sortedFunctions);
-}
-
-async function fetchLogs(functionName) {
- try {
- const response = await fetch(`${apiLogsUrl}${encodeURIComponent(functionName)}`);
- if (!response.ok) {
- throw new Error('Failed to fetch logs');
- }
- const logs = await response.json();
- return {
- total_logs: logs.length,
- last_log_date: logs.length > 0 ? logs[logs.length - 1].timestamp : null
- };
- } catch (error) {
- console.error(`Error fetching logs for ${functionName}:`, error);
- return { total_logs: 0, last_log_date: null };
- }
-}
-
-function updateLogsAsync(tasks) {
- const promises = tasks.map(([functionName, row]) => {
- return fetchLogs(functionName).then(({ total_logs, last_log_date }) => {
- const totalLogsCell = row.querySelector('.total-logs');
- const lastLogDateCell = row.querySelector('.last-log-date');
- totalLogsCell.textContent = total_logs;
- lastLogDateCell.textContent = last_log_date ? new Date(last_log_date).toLocaleDateString() : 'N/A';
-
- // Update function in allFunctions array
- const func = allFunctions.find(f => f.name === functionName);
- if (func) {
- func.total_logs = total_logs;
- func.last_log_date = last_log_date;
- }
- });
- });
- return Promise.all(promises);
-}
-
-async function populateDashboard(functions) {
- allFunctions = functions; // Store functions globally for sorting
- const tableBody = document.querySelector('#functionTable tbody');
- const grid = document.getElementById('functionGrid');
- const logTasks = [];
-
- tableBody.innerHTML = '';
- grid.innerHTML = '';
-
- for (const func of functions) {
- const row = document.createElement('tr');
- const description = func.metadata && func.metadata.description ? func.metadata.description : 'No description available';
- const createdDate = new Date(func.created_date).toLocaleDateString();
-
- row.innerHTML = `
-
-{% endblock %}
-{% block scripts %}
-
-
-
-{% endblock %}
diff --git a/babyagi/functionz/__init__.py b/babyagi/functionz/__init__.py
deleted file mode 100644
index 108bc817..00000000
--- a/babyagi/functionz/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .core.framework import func
-
-__all__ = ['func']
diff --git a/babyagi/functionz/core/execution.py b/babyagi/functionz/core/execution.py
deleted file mode 100644
index ec50e098..00000000
--- a/babyagi/functionz/core/execution.py
+++ /dev/null
@@ -1,233 +0,0 @@
-import subprocess
-import sys
-import importlib
-import inspect
-from typing import Any, Dict, List, Optional
-from datetime import datetime
-import logging
-
-logger = logging.getLogger(__name__)
-
-class FunctionExecutor:
- def __init__(self, python_func):
- self.python_func = python_func
-
- def _install_external_dependency(self, package_name: str, imp_name: str) -> Any:
- try:
- return importlib.import_module(imp_name)
- except ImportError:
- subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
- return importlib.import_module(package_name)
-
- def _resolve_dependencies(self, function_version: Dict[str, Any], local_scope: Dict[str, Any],
- parent_log_id: Optional[int], executed_functions: List[str],
- visited: Optional[set] = None) -> None:
- if visited is None:
- visited = set()
-
- function_name = function_version['name']
- function_imports = self.python_func.db.get_function_imports(function_name)
-
- for imp in function_imports:
- lib_name = imp['lib'] if imp['lib'] else imp['name']
- if lib_name not in local_scope:
- module = self._install_external_dependency(lib_name, imp['name'])
- local_scope[imp['name']] = module
-
- for dep_name in function_version.get('dependencies', []):
- if dep_name not in local_scope and dep_name not in visited:
- visited.add(dep_name)
- dep_data = self.python_func.db.get_function(dep_name)
- if not dep_data:
- raise ValueError(f"Dependency '{dep_name}' not found in the database.")
- self._resolve_dependencies(dep_data, local_scope, parent_log_id, executed_functions, visited)
- exec(dep_data['code'], local_scope)
- if dep_name in local_scope:
- dep_func = local_scope[dep_name]
- # Wrap the dependent function
- local_scope[dep_name] = self._create_function_wrapper(dep_func, dep_name, parent_log_id, executed_functions)
-
- def _create_function_wrapper(self, func: callable, func_name: str, parent_log_id: int, executed_functions: List[str]):
- def wrapper(*args, **kwargs):
- return self.execute(func_name, *args, executed_functions=executed_functions, parent_log_id=parent_log_id, **kwargs)
- return wrapper
-
- def execute(self, function_name: str, *args, executed_functions: Optional[List[str]] = None,
- parent_log_id: Optional[int] = None, triggered_by_log_id: Optional[int] = None, **kwargs) -> Any:
- start_time = datetime.now()
- executed_functions = executed_functions or []
- log_id = None
- bound_args = None
- output = None
-
- logger.info(f"Executing function: {function_name}")
- logger.debug(f"Args: {args}")
- logger.debug(f"Kwargs: {kwargs}")
- logger.debug(f"Executed functions: {executed_functions}")
-
- try:
- #if function_name in executed_functions:
- # logger.warning(f"Function '{function_name}' is already executed in this chain. Skipping to prevent recursion.")
- # return None
-
- executed_functions.append(function_name)
-
- function_version = self.python_func.db.get_function(function_name)
- if not function_version:
- raise ValueError(f"Function '{function_name}' not found in the database.")
-
- self._check_key_dependencies(function_version)
-
- # Create execution log with status 'started' and get log_id
- log_id = self._add_execution_log(function_name, start_time, {}, None, 0,
- parent_log_id, triggered_by_log_id, 'started')
-
- # Inject parent_log_id into local_scope
- local_scope = {'func': self.python_func, 'parent_log_id': log_id}
- self._resolve_dependencies(function_version, local_scope, parent_log_id=log_id, executed_functions=executed_functions)
-
- self._inject_secret_keys(local_scope)
-
- logger.debug(f"Local scope before execution: {local_scope.keys()}")
-
- exec(function_version['code'], local_scope)
- if function_name not in local_scope:
- raise ValueError(f"Failed to load function '{function_name}'.")
-
- func = local_scope[function_name]
- bound_args = self._bind_function_arguments(func, args, kwargs)
- self._validate_input_parameters(function_version, bound_args)
-
- params = bound_args.arguments
- self._update_execution_log_params(log_id, params)
-
- logger.info(f"Executing function {function_name} with args: {bound_args.args} and kwargs: {bound_args.kwargs}")
- output = func(*bound_args.args, **bound_args.kwargs)
- logger.info(f"Function {function_name} executed. Output: {output}")
-
- end_time = datetime.now()
- time_spent = (end_time - start_time).total_seconds()
-
- # Update execution log with status 'success'
- self._update_execution_log(log_id, output, time_spent, 'success')
-
- self._execute_triggered_functions(function_name, output, executed_functions, log_id)
-
- logger.info(f"All triggers for {function_name} have been executed.")
- return output
-
- except Exception as e:
- end_time = datetime.now()
- time_spent = (end_time - start_time).total_seconds()
- params = bound_args.arguments if bound_args else {}
-
- # Update execution log with status 'error'
- if log_id is not None:
- self._update_execution_log(log_id, None, time_spent, 'error', str(e))
-
- #logger.error(f"Error executing function '{function_name}': {str(e)}")
- raise
-
- def _check_key_dependencies(self, function_version: Dict[str, Any]) -> None:
- if 'key_dependencies' in function_version.get('metadata', {}):
- for key_name in function_version['metadata']['key_dependencies']:
- if key_name not in self.python_func.db.get_all_secret_keys():
- raise ValueError(f"Required secret key '{key_name}' not found for function '{function_version['name']}'")
-
- def _inject_secret_keys(self, local_scope: Dict[str, Any]) -> None:
- secret_keys = self.python_func.db.get_all_secret_keys()
- if secret_keys:
- logger.debug(f"Injecting secret keys: {list(secret_keys.keys())}")
- local_scope.update(secret_keys)
-
- def _bind_function_arguments(self, func: callable, args: tuple, kwargs: dict) -> inspect.BoundArguments:
- sig = inspect.signature(func)
- bound_args = sig.bind(*args, **kwargs)
- bound_args.apply_defaults()
- return bound_args
-
- def _validate_input_parameters(self, function_version: Dict[str, Any], bound_args: inspect.BoundArguments) -> None:
- input_params = function_version.get('input_parameters', [])
- for param in input_params:
- if param['name'] not in bound_args.arguments:
- raise ValueError(f"Missing required input parameter '{param['name']}' for function '{function_version['name']}'")
-
- def _add_execution_log(self, function_name: str, start_time: datetime, params: Dict[str, Any],
- output: Any, time_spent: float, parent_log_id: Optional[int],
- triggered_by_log_id: Optional[int], log_type: str, error_message: Optional[str] = None) -> int:
- if log_type == 'started':
- message = "Execution started."
- elif log_type == 'success':
- message = "Execution successful."
- else:
- message = f"Execution failed. Error: {error_message}"
- return self.python_func.db.add_log(
- function_name=function_name,
- message=message,
- timestamp=start_time,
- params=params,
- output=output,
- time_spent=time_spent,
- parent_log_id=parent_log_id,
- triggered_by_log_id=triggered_by_log_id,
- log_type=log_type
- )
-
- def _update_execution_log(self, log_id: int, output: Any, time_spent: float, log_type: str,
- error_message: Optional[str] = None):
- message = "Execution successful." if log_type == 'success' else f"Execution failed. Error: {error_message}"
- update_data = {
- 'message': message,
- 'log_type': log_type
- }
- if output is not None:
- update_data['output'] = output
- if time_spent is not None:
- update_data['time_spent'] = time_spent
-
- self.python_func.db.update_log(log_id=log_id, **update_data)
-
-
- def _update_execution_log_params(self, log_id: int, params: Dict[str, Any]) -> None:
- self.python_func.db.update_log(log_id=log_id, params=params)
-
-
-
- def _execute_triggered_functions(self, function_name: str, output: Any, executed_functions: List[str], log_id: int) -> None:
- triggered_function_names = self.python_func.db.get_triggers_for_function(function_name)
- logger.info(f"Functions triggered by {function_name}: {triggered_function_names}")
-
- for triggered_function_name in triggered_function_names:
- if triggered_function_name in executed_functions:
- logger.warning(f"Triggered function '{triggered_function_name}' already executed in this chain. Skipping to prevent recursion.")
- continue
-
- try:
- logger.info(f"Preparing to execute trigger: {triggered_function_name}")
- triggered_function = self.python_func.db.get_function(triggered_function_name)
- if triggered_function:
- trigger_args, trigger_kwargs = self._prepare_trigger_arguments(triggered_function, output)
- logger.info(f"Executing trigger {triggered_function_name} with args: {trigger_args} and kwargs: {trigger_kwargs}")
-
- trigger_output = self.execute(
- triggered_function_name,
- *trigger_args,
- executed_functions=executed_functions.copy(),
- parent_log_id=log_id,
- triggered_by_log_id=log_id,
- **trigger_kwargs
- )
- logger.info(f"Trigger {triggered_function_name} execution completed. Output: {trigger_output}")
- else:
- logger.error(f"Triggered function '{triggered_function_name}' not found in the database.")
- except Exception as e:
- logger.error(f"Error executing triggered function '{triggered_function_name}': {str(e)}")
-
- def _prepare_trigger_arguments(self, triggered_function: Dict[str, Any], output: Any) -> tuple:
- triggered_params = triggered_function.get('input_parameters', [])
- if triggered_params:
- # If the triggered function expects parameters, pass the output as the first parameter
- return (output,), {}
- else:
- # If the triggered function doesn't expect parameters, don't pass any
- return (), {}
diff --git a/babyagi/functionz/core/framework.py b/babyagi/functionz/core/framework.py
deleted file mode 100644
index de9091cb..00000000
--- a/babyagi/functionz/core/framework.py
+++ /dev/null
@@ -1,150 +0,0 @@
-# core/framework.py
-
-import os
-import sys
-import importlib.util
-from typing import Optional, List, Dict, Any
-from datetime import datetime
-import logging
-
-from ..db.db_router import DBRouter
-from .execution import FunctionExecutor
-from .registration import FunctionRegistrar
-
-logger = logging.getLogger(__name__)
-
-class Functionz:
- def __init__(self, db_type='local', **db_kwargs):
- self.db = DBRouter(db_type, **db_kwargs)
- self.executor = FunctionExecutor(self)
- self.registrar = FunctionRegistrar(self)
-
- # Function execution
- def execute_function(self, function_name: str, *args, **kwargs):
- return self.executor.execute(function_name, *args, **kwargs)
-
- def __getattr__(self, name):
- if self.db.get_function(name):
- return lambda *args, **kwargs: self.executor.execute(name, *args, **kwargs)
- raise AttributeError(f"'PythonFunc' object has no attribute '{name}'")
-
- # Function management
- def get_function(self, name: str):
- return self.db.get_function(name)
-
- def get_function_versions(self, name: str):
- return self.db.get_function_versions(name)
-
- def get_all_functions(self) -> List[Dict[str, Any]]:
- return self.db.get_all_functions()
-
- def activate_function_version(self, name: str, version: int) -> None:
- self.db.activate_function_version(name, version)
-
- def get_function_imports(self, name: str):
- return self.db.get_function_imports(name)
-
- # Function registration (exposing registrar methods)
- def register_function(self, *args, **kwargs):
- return self.registrar.register_function(*args, **kwargs)
-
- def update_function(self, *args, **kwargs):
- return self.registrar.update_function(*args, **kwargs)
-
- def add_function(self, *args, **kwargs):
- return self.registrar.add_function(*args, **kwargs)
-
- # Key management
- def add_key(self, key_name: str, key_value: str) -> None:
- self.db.add_secret_key(key_name, key_value)
-
- def get_all_secret_keys(self, *args, **kwargs):
- return self.db.get_all_secret_keys(*args, **kwargs)
-
- # Import management
- def get_all_imports(self, *args, **kwargs):
- return self.db.get_all_imports(*args, **kwargs)
-
- # Function pack and file loading
- def load_function_pack(self, pack_name: str):
- packs_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'packs')
- pack_path = os.path.join(packs_dir, pack_name + '.py')
-
- if not os.path.exists(pack_path):
- logger.error(f"Function pack '{pack_name}' not found.")
- return
-
- self._load_module_from_path(pack_path, pack_name)
-
- def load_functions_from_file(self, file_path: str):
- if not os.path.exists(file_path):
- logger.error(f"File '{file_path}' not found.")
- return
-
- module_name = os.path.splitext(os.path.basename(file_path))[0]
- self._load_module_from_path(file_path, module_name)
-
- def _load_module_from_path(self, path: str, module_name: str):
- spec = importlib.util.spec_from_file_location(module_name, path)
- module = importlib.util.module_from_spec(spec)
- module.func = self
-
- original_sys_path = sys.path[:]
- try:
- babyagi_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
- if babyagi_root not in sys.path:
- sys.path.insert(0, babyagi_root)
-
- spec.loader.exec_module(module)
- logger.info(f"Loaded module '{module_name}' from '{path}'")
- except Exception as e:
- logger.error(f"Error loading module '{module_name}' from '{path}': {str(e)}")
- import traceback
- logger.error(traceback.format_exc())
- finally:
- sys.path = original_sys_path
-
- # Trigger management
- def add_trigger(self, triggered_function_name, triggering_function_name=None):
- self.db.add_trigger(triggered_function_name, triggering_function_name)
-
- def get_triggers_for_function(self, function_name: str) -> List[str]:
- function_data = self.get_function(function_name)
- return function_data.get('triggers', []) if function_data else []
-
- # Logging and display
- def get_logs(self, function_name: Optional[str] = None,
- start_date: Optional[datetime] = None,
- end_date: Optional[datetime] = None) -> List[Dict[str, Any]]:
- return self.db.get_logs(function_name, start_date, end_date)
-
- def display(self):
- functions = self.db.get_all_functions()
- result = []
-
- for function in functions:
- function_info = [
- f"Function: {function['name']}",
- f" Version: {function['version']}",
- f" Created Date: {function['created_date']}",
- f" Metadata: {function['metadata']}",
- f" Dependencies: {function['dependencies']}",
- f" Triggers: {function.get('triggers', [])}",
- " Input Parameters:",
- ]
- for param in function['input_parameters']:
- function_info.append(f" - {param['name']} ({param['type']})")
-
- function_info.append(" Output Parameters:")
- for param in function['output_parameters']:
- function_info.append(f" - {param['name']} ({param['type']})")
-
- function_info.append(f" Code:\n{function['code']}")
- function_info.append("---")
-
- result.append("\n".join(function_info))
-
- return "\n\n".join(result)
-
-# Create the global 'func' instance
-func = Functionz()
\ No newline at end of file
diff --git a/babyagi/functionz/core/registration.py b/babyagi/functionz/core/registration.py
deleted file mode 100644
index 47e53d3c..00000000
--- a/babyagi/functionz/core/registration.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# core/registration.py
-
-from .execution import FunctionExecutor
-import inspect
-import ast
-from typing import Optional, List, Dict, Any, Union
-import logging
-import json
-
-logger = logging.getLogger(__name__)
-
-class FunctionRegistrar:
- def __init__(self, python_func):
- self.python_func = python_func
-
- def register_function(self, metadata: Optional[Dict[str, Any]] = None,
- imports: Optional[List[str]] = None,
- dependencies: Optional[List[str]] = None,
- triggers: Optional[List[str]] = None,
- key_dependencies: Optional[List[str]] = None):
- """Decorator to register a function."""
- def decorator(func):
- function_name = func.__name__
- source_lines = inspect.getsourcelines(func)[0]
- func_start = next(i for i, line in enumerate(source_lines) if line.strip().startswith('def '))
- function_code = ''.join(source_lines[func_start:]).strip()
-
- # Store metadata on the function object
- func.__pythonfunc_metadata__ = {
- 'metadata': metadata or {},
- 'imports': imports or [],
- 'dependencies': dependencies or [],
- 'triggers': triggers or [],
- 'key_dependencies': key_dependencies or []
- }
-
- self.add_function(function_name, metadata=metadata, code=function_code,
- imports=imports, dependencies=dependencies,
- key_dependencies=key_dependencies, triggers=triggers)
- def wrapper(*args, **kwargs):
- return self.python_func.executor.execute(function_name, *args, **kwargs)
- return wrapper
- return decorator
-
- def parse_function_parameters(self, code: str):
- """
- Parse the input and output parameters of a given function code.
- """
- try:
- # Parse the source code into an AST
- tree = ast.parse(code)
-
- # Find the function definition node
- function_def = next(node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef))
-
- # Parse input parameters
- input_params = []
- for arg in function_def.args.args:
- param_type = 'Any'
- if arg.annotation:
- param_type = ast.unparse(arg.annotation)
- input_params.append({'name': arg.arg, 'type': param_type})
-
- # Parse return statement to identify output parameters
- output_params = []
- returns = [node for node in ast.walk(function_def) if isinstance(node, ast.Return)]
- if returns:
- return_node = returns[0].value
- if isinstance(return_node, ast.Dict):
- # If returning a dictionary, treat each key as an output parameter
- for key in return_node.keys:
- if isinstance(key, ast.Str):
- output_params.append({'name': key.s, 'type': 'Any'})
- elif isinstance(return_node, (ast.Name, ast.Attribute)):
- # If returning a single variable
- output_params.append({'name': 'output', 'type': 'Any'})
- elif isinstance(return_node, ast.Str):
- # If returning a string literal
- output_params.append({'name': 'output', 'type': 'str'})
- else:
- # For other types of returns, use a generic 'output' parameter
- output_params.append({'name': 'output', 'type': 'Any'})
-
- return input_params, output_params
- except Exception as e:
- # print(f"Error parsing function parameters: {str(e)}")
- return [], []
-
- def parse_import(self, imp):
- try:
- #print("Attempt to parse the string as JSON")
- #print(imp.type())
- parsed = json.loads(imp)
- #print("Parsed string as JSON")
- return parsed
- except json.JSONDecodeError:
- print("Failed to parse the string as JSON")
- # If it fails, return the original string (it's a simple import)
- return imp
-
- # Register imports helper function
- def register_imports(self, imports):
- print(f"Registering imports: {imports}")
- if isinstance(imports, list):
- for imp in imports:
- self.process_single_import(imp)
- elif isinstance(imports, dict):
- self.process_single_import(imports)
-
- def process_single_import(self, imp):
- if isinstance(imp, str):
- self.python_func.db.add_import(imp, 'external', lib=None)
- elif isinstance(imp, dict):
- name = imp.get('name')
- lib = imp.get('lib')
- if name:
- self.python_func.db.add_import(name, 'external', lib=lib)
- else:
- print(f"Unsupported import format: {imp}")
-
- def process_imports(self, imports):
- import_names = []
- if imports:
- if isinstance(imports, list):
- for imp in imports:
- if isinstance(imp, str):
- import_names.append(imp)
- elif isinstance(imp, dict):
- import_name = imp.get('name')
- if import_name:
- import_names.append(import_name)
- elif isinstance(imports, dict):
- import_name = imports.get('name')
- if import_name:
- import_names.append(import_name)
- return import_names
-
- def function_has_no_changes(self, name, code, metadata, import_names, dependencies, triggers):
- existing_function = self.python_func.db.get_function(name)
- if not existing_function:
- return False # Function does not exist, so changes are needed
-
- existing_code = existing_function.get('code')
- existing_metadata = existing_function.get('metadata', {})
- existing_description = existing_metadata.get('description')
- existing_imports = existing_function.get('imports') or []
- existing_dependencies = existing_function.get('dependencies') or []
- existing_triggers = existing_function.get('triggers') or []
-
- new_description = metadata.get('description') if metadata else None
-
- if (existing_code == code and
- existing_description == new_description and
- set(existing_imports) == set(import_names) and
- set(existing_dependencies) == set(dependencies) and
- set(existing_triggers) == set(triggers)):
- return True # No changes
- else:
- return False # Changes detected
-
- def add_function(self, name: str, metadata: Optional[Dict[str, Any]] = None,
- code: Optional[str] = None, imports: Optional[List[Union[str, Dict[str, str]]]] = None,
- dependencies: Optional[List[str]] = None, triggers: Optional[List[str]] = None,
- key_dependencies: Optional[List[str]] = None,
- input_parameters: Optional[List[Dict[str, str]]] = None,
- output_parameters: Optional[List[Dict[str, str]]] = None) -> None:
-
- if code:
- # Parse input and output parameters if not provided
- if input_parameters is None or output_parameters is None:
- parsed_input, parsed_output = self.parse_function_parameters(code)
- input_parameters = input_parameters or parsed_input
- output_parameters = output_parameters or parsed_output
-
- # Process imports
- import_names = self.process_imports(imports)
-
- # Ensure lists are not None
- dependencies = dependencies or []
- triggers = triggers or []
-
- # Check for changes
- if self.function_has_no_changes(name, code, metadata, import_names, dependencies, triggers):
- #print(f"Function {name} has no changes.")
- return
-
- # Register imports
- if imports:
- self.register_imports(imports)
-
- # Add or update the function in the database
- existing_function = self.python_func.db.get_function(name)
- if existing_function:
- # Function exists, update it
- self.python_func.db.update_function(
- name, code=code, metadata=metadata, dependencies=dependencies,
- input_parameters=input_parameters, output_parameters=output_parameters,
- imports=import_names, triggers=triggers
- )
- else:
- # Function does not exist, add it
- self.python_func.db.add_function(
- name, code=code, metadata=metadata, dependencies=dependencies,
- input_parameters=input_parameters, output_parameters=output_parameters,
- imports=import_names, triggers=triggers
- )
-
- if key_dependencies:
- print(f"Function {name} requires keys: {key_dependencies}")
- metadata = metadata or {}
- metadata['key_dependencies'] = key_dependencies
-
- if self.python_func.db.get_function('function_added_or_updated'):
- try:
- action = 'updated' if existing_function else 'added'
- self.python_func.executor.execute(function_name='function_added_or_updated', action=action, triggered_function_name=name)
- except Exception as e:
- logger.error(f"Error executing trigger function 'function_added_or_updated': {str(e)}")
-
- def update_function(self, name: str, code: Optional[str] = None, imports: Optional[List[Union[str, Dict[str, str]]]] = None,
- metadata: Optional[Dict[str, Any]] = None,
- dependencies: Optional[List[str]] = None,
- triggers: Optional[List[str]] = None,
- key_dependencies: Optional[List[str]] = None,
- input_parameters: Optional[List[Dict[str, str]]] = None,
- output_parameters: Optional[List[Dict[str, str]]] = None) -> None:
-
- if code:
- # Parse input and output parameters if not provided
- if input_parameters is None or output_parameters is None:
- parsed_input, parsed_output = self.parse_function_parameters(code)
- input_parameters = input_parameters or parsed_input
- output_parameters = output_parameters or parsed_output
-
- # Process imports
- import_names = self.process_imports(imports)
-
- # Ensure lists are not None
- dependencies = dependencies or []
- triggers = triggers or []
-
- # Check for changes
- if self.function_has_no_changes(name, code, metadata, import_names, dependencies, triggers):
- # print(f"Function {name} has no changes.")
- return
-
- # Update the function in the database
- self.python_func.db.update_function(
- name, code=code, metadata=metadata, dependencies=dependencies,
- input_parameters=input_parameters, output_parameters=output_parameters,
- imports=import_names, triggers=triggers
- )
-
- if key_dependencies:
- metadata = metadata or {}
- metadata['key_dependencies'] = key_dependencies
-
- # Register imports
- if imports:
- self.register_imports(imports)
-
- if self.python_func.db.get_function('function_added_or_updated'):
- try:
- self.python_func.executor.execute(function_name='function_added_or_updated', action='updated', triggered_function_name=name)
- except Exception as e:
- logger.error(f"Error executing trigger function 'function_added_or_updated': {str(e)}")
diff --git a/babyagi/functionz/db/base_db.py b/babyagi/functionz/db/base_db.py
deleted file mode 100644
index 17dded9c..00000000
--- a/babyagi/functionz/db/base_db.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional, List, Dict, Any
-from datetime import datetime
-
-class BaseDB(ABC):
- # Function management
- @abstractmethod
- def add_function(self, name: str, code: str, metadata: Optional[Dict[str, Any]] = None,
- dependencies: Optional[List[str]] = None,
- input_parameters: Optional[List[Dict[str, Any]]] = None,
- output_parameters: Optional[List[Dict[str, Any]]] = None) -> None:
- pass
-
- @abstractmethod
- def get_function(self, name: str) -> Optional[Dict[str, Any]]:
- pass
-
- @abstractmethod
- def get_all_functions(self) -> List[Dict[str, Any]]:
- pass
-
- @abstractmethod
- def update_function(self, name: str, code: Optional[str] = None,
- metadata: Optional[Dict[str, Any]] = None,
- dependencies: Optional[List[str]] = None,
- input_parameters: Optional[List[Dict[str, Any]]] = None,
- output_parameters: Optional[List[Dict[str, Any]]] = None) -> None:
- pass
-
- @abstractmethod
- def remove_function(self, name: str) -> None:
- pass
-
- @abstractmethod
- def get_function_versions(self, name: str) -> List[Dict[str, Any]]:
- pass
-
- @abstractmethod
- def activate_function_version(self, name: str, version: int) -> None:
- pass
-
- # Import management
- @abstractmethod
- def add_import(self, name: str, source: str, lib: Optional[str] = None) -> None:
- pass
-
- @abstractmethod
- def get_all_imports(self) -> List[Dict[str, Any]]:
- pass
-
- # Logging
- @abstractmethod
- def add_log(self, function_name: str, message: str, timestamp: datetime,
- params: Optional[Dict[str, Any]] = None,
- output: Optional[Any] = None,
- time_spent: Optional[float] = None) -> None:
- pass
-
- @abstractmethod
- def get_logs(self, function_name: Optional[str] = None,
- start_date: Optional[datetime] = None,
- end_date: Optional[datetime] = None) -> List[Dict[str, Any]]:
- pass
\ No newline at end of file
diff --git a/babyagi/functionz/db/db_router.py b/babyagi/functionz/db/db_router.py
deleted file mode 100644
index 060797c2..00000000
--- a/babyagi/functionz/db/db_router.py
+++ /dev/null
@@ -1,302 +0,0 @@
-from typing import List, Optional, Dict, Any
-from contextlib import contextmanager
-from datetime import datetime
-
-from .local_db import LocalDB
-from .base_db import BaseDB
-from .models import Import, Function, FunctionVersion, Log
-
-class ImportResult:
- def __init__(self, name: str, source: str):
- self.name = name
- self.source = source
-
-class DBRouter(BaseDB):
- def __init__(self, db_type: str = 'local', **kwargs):
- if db_type == 'local':
- self.db = LocalDB(**kwargs)
- else:
- raise ValueError(f"Unsupported database type: {db_type}")
-
- @contextmanager
- def session_scope(self):
- with self.db.session_scope() as session:
- yield session
-
- # Function management
- def add_function(self, name: str, code: str, metadata: Optional[Dict[str, Any]] = None,
- dependencies: Optional[List[str]] = None,
- triggers: Optional[List[str]] = None,
- input_parameters: Optional[List[Dict[str, str]]] = None,
- output_parameters: Optional[List[Dict[str, str]]] = None,
- imports: Optional[List[str]] = None) -> None:
- with self.session_scope() as session:
- self.db.add_or_update_function(session, name, code, metadata, dependencies, triggers, input_parameters, output_parameters, imports)
-
- def update_function(self, name: str, code: Optional[str] = None,
- metadata: Optional[Dict[str, Any]] = None,
- dependencies: Optional[List[str]] = None,
- triggers: Optional[List[str]] = None,
- input_parameters: Optional[List[Dict[str, str]]] = None,
- output_parameters: Optional[List[Dict[str, str]]] = None,
- imports: Optional[List[str]] = None) -> None:
- with self.session_scope() as session:
- function = self.db.get_function(session, name)
- if function:
- active_version = self.db.get_active_version(session, function)
- self.db.add_or_update_function(
- session, name,
- code if code is not None else active_version.code,
- metadata or active_version.function_metadata,
- dependencies,
- triggers if triggers is not None else active_version.triggers,
- input_parameters or active_version.input_parameters,
- output_parameters or active_version.output_parameters,
- imports
- )
-
- def get_function(self, name: str) -> Optional[Dict[str, Any]]:
- with self.session_scope() as session:
- function = self.db.get_function(session, name)
- if function:
- active_version = self.db.get_active_version(session, function)
- if active_version:
- return {
- 'name': function.name,
- 'version': active_version.version,
- 'code': active_version.code,
- 'metadata': active_version.function_metadata,
- 'dependencies': [dep.name for dep in active_version.dependencies],
- 'imports': [imp.name for imp in active_version.imports],
- 'created_date': active_version.created_date.isoformat(),
- 'input_parameters': active_version.input_parameters,
- 'output_parameters': active_version.output_parameters,
- 'triggers': active_version.triggers
- }
- return None
-
- def get_all_functions(self) -> List[Dict[str, Any]]:
- with self.session_scope() as session:
- functions = self.db.get_all_functions(session)
- return [
- {
- 'name': function.name,
- 'version': active_version.version,
- 'code': active_version.code,
- 'metadata': active_version.function_metadata,
- 'dependencies': [dep.name for dep in active_version.dependencies],
- 'imports': [imp.name for imp in active_version.imports],
- 'created_date': active_version.created_date.isoformat(),
- 'input_parameters': active_version.input_parameters,
- 'output_parameters': active_version.output_parameters,
- 'triggers': active_version.triggers
- }
- for function in functions
- if (active_version := next((v for v in function.versions if v.is_active), None))
- ]
-
- def remove_function(self, name: str) -> None:
- with self.session_scope() as session:
- function = self.db.get_function(session, name)
- if function:
- session.delete(function)
-
- def get_function_versions(self, name: str) -> List[Dict[str, Any]]:
- with self.session_scope() as session:
- function = self.db.get_function(session, name)
- if function:
- return [
- {
- 'version': v.version,
- 'code': v.code,
- 'metadata': v.function_metadata,
- 'is_active': v.is_active,
- 'dependencies': [dep.name for dep in v.dependencies],
- 'created_date': v.created_date.isoformat(),
- 'input_parameters': v.input_parameters,
- 'output_parameters': v.output_parameters,
- 'triggers': v.triggers
- }
- for v in function.versions
- ]
- return []
-
- def activate_function_version(self, name: str, version: int) -> None:
- with self.session_scope() as session:
- function = self.db.get_function(session, name)
- if function:
- for v in function.versions:
- v.is_active = (v.version == version)
-
- # Import management
- def add_import(self, name: str, source: str, lib: Optional[str] = None) -> None:
- with self.session_scope() as session:
- self.db.add_import(session, name, source, lib)
-
- def get_all_imports(self) -> List[Dict[str, Any]]:
- with self.session_scope() as session:
- imports = session.query(Import).all()
- return [{"name": imp.name, "source": imp.source, "lib": imp.lib} for imp in imports]
-
- def get_function_imports(self, function_name: str) -> List[Dict[str, Any]]:
- with self.session_scope() as session:
- function = session.query(Function).filter_by(name=function_name).first()
- if function:
- imports = (session.query(Import)
- .join(FunctionVersion.imports)
- .filter(FunctionVersion.function_id == function.id)
- .all())
- return [{"name": imp.name, "source": imp.source, "lib": imp.lib} for imp in imports]
- return []
-
- # Logging
- def add_log(self, function_name: str, message: str, timestamp: datetime,
- params: Optional[Dict[str, Any]] = None,
- output: Optional[Any] = None,
- time_spent: Optional[float] = None,
- parent_log_id: Optional[int] = None,
- triggered_by_log_id: Optional[int] = None,
- log_type: str = 'info') -> int:
- with self.session_scope() as session:
- return self.db.add_log(
- session=session,
- function_name=function_name,
- message=message,
- timestamp=timestamp,
- params=params,
- output=output,
- time_spent=time_spent,
- parent_log_id=parent_log_id,
- triggered_by_log_id=triggered_by_log_id,
- log_type=log_type
- )
-
- def update_log(self, log_id: int, **kwargs) -> None:
- with self.session_scope() as session:
- self.db.update_log(
- session=session,
- log_id=log_id,
- **kwargs
- )
-
-
- def update_log_params(self, log_id: int, params: Dict[str, Any]) -> None:
- with self.session_scope() as session:
- self.db.update_log_params(
- session=session,
- log_id=log_id,
- params=params
- )
-
-
-
- def get_logs(self, function_name: Optional[str] = None,
- start_date: Optional[datetime] = None,
- end_date: Optional[datetime] = None,
- triggered_by_log_id: Optional[int] = None) -> List[Dict[str, Any]]:
- with self.session_scope() as session:
- logs = self.db.get_logs(session, function_name, start_date, end_date, triggered_by_log_id)
- return [
- {
- 'id': log.id,
- 'function_name': log.function_name,
- 'message': log.message,
- 'timestamp': log.timestamp.isoformat(),
- 'params': log.params,
- 'output': log.output,
- 'time_spent': log.time_spent,
- 'parent_log_id': log.parent_log_id,
- 'triggered_by_log_id': log.triggered_by_log_id,
- 'log_type': log.log_type
- }
- for log in logs
- ]
-
- def get_log_bundle(self, log_id: int) -> List[Dict[str, Any]]:
- with self.session_scope() as session:
- logs_collected = {}
-
- def fetch_related_logs(current_log_id):
- if current_log_id in logs_collected:
- return
- log = self.db.get_log(session, current_log_id)
- if log:
- logs_collected[current_log_id] = log
- else:
- logger.warning(f"Log ID {current_log_id} not found.")
- return
-
- # Fetch parent log
- if log.parent_log_id:
- fetch_related_logs(log.parent_log_id)
-
- # Fetch sibling logs
- sibling_logs = session.query(Log).filter(
- Log.parent_log_id == log.parent_log_id,
- Log.id != current_log_id
- ).all()
- for sibling in sibling_logs:
- fetch_related_logs(sibling.id)
-
- # Fetch child logs
- child_logs = self.db.get_child_logs(session, current_log_id)
- for child in child_logs:
- fetch_related_logs(child.id)
-
- fetch_related_logs(log_id)
-
- # Convert logs to dictionaries
- all_logs = [
- {
- 'id': log.id,
- 'function_name': log.function_name,
- 'message': log.message,
- 'timestamp': log.timestamp.isoformat(),
- 'params': log.params,
- 'output': log.output,
- 'time_spent': log.time_spent,
- 'parent_log_id': log.parent_log_id,
- 'triggered_by_log_id': log.triggered_by_log_id,
- 'log_type': log.log_type
- }
- for log in logs_collected.values()
- ]
-
- return all_logs
-
-
-
- # Secret key management
- def add_secret_key(self, key_name: str, key_value: str) -> None:
- with self.session_scope() as session:
- existing_key = self.db.get_secret_key(session, key_name)
- if existing_key:
- existing_key.value = key_value
- else:
- self.db.add_secret_key(session, key_name, key_value)
-
- def get_secret_key(self, key_name: str) -> Optional[str]:
- with self.session_scope() as session:
- secret_key = self.db.get_secret_key(session, key_name)
- return secret_key.value if secret_key else None
-
- def get_all_secret_keys(self) -> Dict[str, str]:
- with self.session_scope() as session:
- secret_keys = self.db.get_all_secret_keys(session)
- return {key.name: key.value for key in secret_keys if key.value is not None}
-
- # Trigger management
- def add_trigger(self, triggered_function_name: str, triggering_function_name: Optional[str] = None) -> None:
- with self.session_scope() as session:
- self.db.add_trigger(session, triggered_function_name, triggering_function_name)
-
- def get_triggers_for_function(self, function_name: str) -> List[str]:
- with self.session_scope() as session:
- all_functions = self.db.get_all_functions(session)
- triggered_functions = []
- for func in all_functions:
- active_version = self.db.get_active_version(session, func)
- if active_version and active_version.triggers:
- if function_name in active_version.triggers:
- triggered_functions.append(func.name)
- return triggered_functions
\ No newline at end of file
diff --git a/babyagi/functionz/db/local_db.py b/babyagi/functionz/db/local_db.py
deleted file mode 100644
index b3352dc1..00000000
--- a/babyagi/functionz/db/local_db.py
+++ /dev/null
@@ -1,260 +0,0 @@
-# local_db.py
-
-from sqlalchemy import create_engine, or_
-from sqlalchemy.orm import sessionmaker, scoped_session, joinedload
-from sqlalchemy.exc import SQLAlchemyError
-from contextlib import contextmanager
-from .models import Base, Function, FunctionVersion, Import, Log, SecretKey, fernet
-import datetime
-
-
-
-class LocalDB:
- def __init__(self, db_path='sqlite:///funztionz.db'):
- self.engine = create_engine(db_path)
- Base.metadata.create_all(self.engine)
- self.Session = scoped_session(sessionmaker(bind=self.engine))
-
- @contextmanager
- def session_scope(self):
- session = self.Session()
- try:
- yield session
- session.commit()
- except SQLAlchemyError as e:
- session.rollback()
- raise e
- finally:
- self.Session.remove()
-
- def serialize_for_json(self, obj):
- """
- Recursively convert datetime objects to ISO format strings within the given object.
- Handles dictionaries, lists, and individual datetime objects.
- """
- if isinstance(obj, dict):
- return {k: self.serialize_for_json(v) for k, v in obj.items()}
- elif isinstance(obj, list):
- return [self.serialize_for_json(element) for element in obj]
- elif isinstance(obj, datetime.datetime):
- return obj.isoformat()
- else:
- return obj
-
-
- def get_function(self, session, name):
- return session.query(Function).filter_by(name=name).first()
-
- def get_active_version(self, session, function):
- return session.query(FunctionVersion).filter_by(function_id=function.id, is_active=True).options(
- joinedload(FunctionVersion.dependencies)
- ).first()
-
- def get_all_functions(self, session):
- return session.query(Function).options(
- joinedload(Function.versions).joinedload(FunctionVersion.dependencies)
- ).all()
-
- def add_or_update_function(self, session, name, code, metadata, dependencies, triggers, input_parameters, output_parameters, imports=None):
- function = self.get_function(session, name)
- if not function:
- function = Function(name=name)
- session.add(function)
- session.flush()
-
- # Handle imports before creating the FunctionVersion
- import_objects = []
- if imports:
- for import_name in imports:
- imp = session.query(Import).filter_by(name=import_name).first()
- if not imp:
- imp = Import(name=import_name, source='external')
- session.add(imp)
- session.flush()
- import_objects.append(imp)
-
- # Create the FunctionVersion instance, now including triggers as JSON
- version = FunctionVersion(
- function=function,
- version=len(function.versions) + 1,
- code=code,
- function_metadata=metadata or {},
- is_active=True,
- input_parameters=input_parameters or [],
- output_parameters=output_parameters or [],
- imports=import_objects, # Pass the list of Import objects here
- triggers=triggers or [] # Store the triggers as JSON
- )
- session.add(version)
-
- # Handle dependencies
- if dependencies:
- for dep in dependencies:
- dep_func = self.get_function(session, dep)
- if dep_func:
- version.dependencies.append(dep_func)
-
- # Deactivate previous versions
- for v in function.versions:
- if v != version:
- v.is_active = False
-
-
- def add_import(self, session, name, source, lib=None):
- existing_import = session.query(Import).filter_by(name=name).first()
- if not existing_import:
- new_import = Import(name=name, source=source, lib=lib)
- session.add(new_import)
-
-
-
- def add_log(self, session, function_name, message, timestamp, params, output, time_spent, parent_log_id=None, triggered_by_log_id=None, log_type='info'):
- if isinstance(timestamp, str):
- # Convert the string timestamp back to a datetime object
- timestamp = datetime.datetime.fromisoformat(timestamp)
-
- # Serialize params and output to ensure JSON serializability
- serialized_params = self.serialize_for_json(params) if params else None
- serialized_output = self.serialize_for_json(output) if output else None
-
- new_log = Log(
- function_name=function_name,
- message=message,
- timestamp=timestamp,
- params=serialized_params,
- output=serialized_output,
- time_spent=time_spent,
- parent_log_id=parent_log_id,
- triggered_by_log_id=triggered_by_log_id,
- log_type=log_type
- )
- session.add(new_log)
- session.flush() # This ensures new_log.id is populated
- return new_log.id
-
- def update_log(self, session, log_id: int, **kwargs) -> None:
- # Fetch the log entry by id
- log_entry = session.query(Log).filter(Log.id == log_id).first()
- if log_entry:
- # Update only the fields provided in kwargs
- for key, value in kwargs.items():
- if hasattr(log_entry, key):
- setattr(log_entry, key, value)
- else:
- raise ValueError(f"Log has no attribute '{key}'")
- # No need to call session.commit(); it will be committed in the session scope
- else:
- raise ValueError(f"Log with id {log_id} not found.")
-
-
-
- def update_log_params(self, session, log_id: int, params) -> None:
- log_entry = session.query(Log).filter_by(id=log_id).one_or_none()
- if log_entry is None:
- raise ValueError(f"Log entry with id {log_id} not found.")
-
- log_entry.params = params
- session.commit()
-
-
-
- def get_log(self, session, log_id: int):
- """
- Fetches a single log entry by its ID.
-
- :param session: SQLAlchemy session object.
- :param log_id: The ID of the log to retrieve.
- :return: Log object if found, else None.
- """
- return session.query(Log).filter_by(id=log_id).first()
-
- def get_child_logs(self, session, parent_id: int):
- """
- Retrieves all child logs that have the given parent_log_id.
-
- :param session: SQLAlchemy session object.
- :param parent_id: The ID of the parent log.
- :return: List of Log objects.
- """
- return session.query(Log).filter_by(parent_log_id=parent_id).all()
-
- def get_logs(self, session, function_name=None, start_date=None, end_date=None, triggered_by_log_id=None):
- query = session.query(Log)
-
- if function_name:
- query = query.filter(Log.function_name == function_name)
-
- if start_date:
- query = query.filter(Log.timestamp >= start_date)
-
- if end_date:
- query = query.filter(Log.timestamp <= end_date)
-
- if triggered_by_log_id:
- query = query.filter(Log.triggered_by_log_id == triggered_by_log_id)
-
- return query.all()
-
-
- def get_log_bundle(self, session, log_id):
- logs_collected = {}
-
- def fetch_related_logs(current_log_id):
- if current_log_id in logs_collected:
- return
- log = session.query(Log).filter_by(id=current_log_id).one_or_none()
- if not log:
- return
- logs_collected[current_log_id] = log
-
- # Fetch parent log
- if log.parent_log_id:
- fetch_related_logs(log.parent_log_id)
-
- # Fetch sibling logs
- sibling_logs = session.query(Log).filter(
- Log.parent_log_id == log.parent_log_id,
- Log.id != current_log_id
- ).all()
- for sibling in sibling_logs:
- if sibling.id not in logs_collected:
- fetch_related_logs(sibling.id)
-
- # Fetch child logs
- child_logs = session.query(Log).filter_by(parent_log_id=current_log_id).all()
- for child in child_logs:
- if child.id not in logs_collected:
- fetch_related_logs(child.id)
-
- fetch_related_logs(log_id)
- return list(logs_collected.values())
-
-
-
-
- def add_secret_key(self, session, function_id, key_name, key_value):
- print(f"Encrypting value for key '{key_name}'")
- try:
- encrypted_value = fernet.encrypt(key_value.encode())
- print(f"Value encrypted successfully for key '{key_name}'")
- secret_key = SecretKey(function_id=function_id, name=key_name, _encrypted_value=encrypted_value)
- session.add(secret_key)
- print(f"Secret key '{key_name}' added to session")
- except Exception as e:
- print(f"Error in add_secret_key: {str(e)}")
- raise
-
-
- def add_secret_key(self, session, key_name, key_value):
- encrypted_value = fernet.encrypt(key_value.encode())
- secret_key = SecretKey(name=key_name, _encrypted_value=encrypted_value)
- session.add(secret_key)
-
- def get_secret_key(self, session, key_name):
- return session.query(SecretKey).filter_by(name=key_name).first()
-
-
- def get_all_secret_keys(self, session):
- return session.query(SecretKey).all()
-
-
\ No newline at end of file
diff --git a/babyagi/functionz/db/models.py b/babyagi/functionz/db/models.py
deleted file mode 100644
index 321e29bb..00000000
--- a/babyagi/functionz/db/models.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# models.py
-
-from sqlalchemy import Column, Integer, String, DateTime, JSON, ForeignKey, Boolean, Table, Float, LargeBinary
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import relationship
-from cryptography.fernet import Fernet
-from cryptography.fernet import InvalidToken
-from sqlalchemy.ext.hybrid import hybrid_property
-import os
-import json
-from datetime import datetime
-
-Base = declarative_base()
-
-KEY_FILE = 'encryption_key.json'
-
-def get_or_create_key():
- if os.path.exists(KEY_FILE):
- with open(KEY_FILE, 'r') as f:
- return json.load(f)['key']
- else:
- key = Fernet.generate_key().decode()
- with open(KEY_FILE, 'w') as f:
- json.dump({'key': key}, f)
- return key
-
-ENCRYPTION_KEY = get_or_create_key()
-print(f"Using encryption key: {ENCRYPTION_KEY}")
-fernet = Fernet(ENCRYPTION_KEY.encode())
-
-# Association table for function dependencies (many-to-many between FunctionVersion and Function)
-function_dependency = Table('function_dependency', Base.metadata,
- Column('function_version_id', Integer, ForeignKey('function_versions.id')),
- Column('dependency_id', Integer, ForeignKey('functions.id'))
-)
-
-# **Define function_version_imports association table here**
-function_version_imports = Table('function_version_imports', Base.metadata,
- Column('function_version_id', Integer, ForeignKey('function_versions.id')),
- Column('import_id', Integer, ForeignKey('imports.id'))
-)
-
-
-class Function(Base):
- __tablename__ = 'functions'
- id = Column(Integer, primary_key=True)
- name = Column(String, unique=True)
- versions = relationship("FunctionVersion", back_populates="function", cascade="all, delete-orphan")
-
-class FunctionVersion(Base):
- __tablename__ = 'function_versions'
- id = Column(Integer, primary_key=True)
- function_id = Column(Integer, ForeignKey('functions.id'))
- version = Column(Integer)
- code = Column(String)
- function_metadata = Column(JSON)
- is_active = Column(Boolean, default=False)
- created_date = Column(DateTime, default=datetime.utcnow)
- input_parameters = Column(JSON)
- output_parameters = Column(JSON)
- function = relationship("Function", back_populates="versions")
- dependencies = relationship('Function', secondary=function_dependency,
- primaryjoin=(function_dependency.c.function_version_id == id),
- secondaryjoin=(function_dependency.c.dependency_id == Function.id))
- imports = relationship('Import', secondary=function_version_imports, back_populates='function_versions')
- triggers = Column(JSON, nullable=True) # Store triggers as a JSON field
-
-
-
-class Import(Base):
- __tablename__ = 'imports'
- id = Column(Integer, primary_key=True)
- name = Column(String, unique=True)
- lib = Column(String, nullable=True)
- source = Column(String)
- function_versions = relationship('FunctionVersion', secondary=function_version_imports, back_populates='imports')
-
-
-class Log(Base):
- __tablename__ = 'logs'
-
- id = Column(Integer, primary_key=True)
- function_name = Column(String, nullable=False)
- message = Column(String, nullable=False)
- timestamp = Column(DateTime, nullable=False)
- params = Column(JSON, nullable=True)
- output = Column(JSON, nullable=True)
- time_spent = Column(Float, nullable=True)
- log_type = Column(String, nullable=False)
-
- # Parent Log Relationship
- parent_log_id = Column(Integer, ForeignKey('logs.id'), nullable=True)
- parent_log = relationship(
- 'Log',
- remote_side=[id],
- backref='child_logs',
- foreign_keys=[parent_log_id]
- )
-
- # Triggered By Log Relationship
- triggered_by_log_id = Column(Integer, ForeignKey('logs.id'), nullable=True)
- triggered_by_log = relationship(
- 'Log',
- remote_side=[id],
- backref='triggered_logs',
- foreign_keys=[triggered_by_log_id]
- )
-
-
-class SecretKey(Base):
- __tablename__ = 'secret_keys'
- id = Column(Integer, primary_key=True)
- name = Column(String, nullable=False, unique=True) # Make name unique
- _encrypted_value = Column(LargeBinary, nullable=False)
-
- @hybrid_property
- def value(self):
- if self._encrypted_value:
- try:
- return fernet.decrypt(self._encrypted_value).decode()
- except InvalidToken:
- print(f"Error decrypting value for key: {self.name}. The encryption key may have changed.")
- return None
- return None
-
- @value.setter
- def value(self, plaintext_value):
- if plaintext_value:
- self._encrypted_value = fernet.encrypt(plaintext_value.encode())
- else:
- self._encrypted_value = None
-
diff --git a/babyagi/functionz/packs/default/ai_functions.py b/babyagi/functionz/packs/default/ai_functions.py
deleted file mode 100644
index c7e4375f..00000000
--- a/babyagi/functionz/packs/default/ai_functions.py
+++ /dev/null
@@ -1,262 +0,0 @@
-# packs/ai_generator.py
-
-from functionz.core.framework import func
-
-@func.register_function(
- metadata={"description": "GPT Call function using LiteLLm"},
- imports=["litellm"],
- key_dependencies=["openai_api_key"]
-)
-def gpt_call(prompt: str) -> str:
- from litellm import completion
- messages = [{"role": "user", "content": prompt}]
- response = completion(model="gpt-3.5-turbo", messages=messages)
- return response['choices'][0]['message']['content']
-
-@func.register_function(
- metadata={"description": "Generates a description for a function using LiteLLm"},
- dependencies=["gpt_call"]
-)
-def description_writer(function_code: str) -> str:
- prompt = (
- f"Provide a concise and clear description for the following Python function:\n\n"
- f"{function_code}\n\n"
- f"Description:"
- )
- description = func.gpt_call(prompt)
- return description
-
-@func.register_function(
- metadata={"description": "Generates and updates descriptions for functions lacking one or having an empty description"},
- dependencies=["description_writer"],
- triggers=["function_added_or_updated"]
-)
-def ai_description_generator(function_name: str) -> None:
- print(f"Generating AI description for function: {function_name}")
- function = func.db.get_function(function_name)
- if not function:
- print(f"Function '{function_name}' not found in the database.")
- return
-
- description = function.get('metadata', {}).get('description', '').strip()
- function_code = function.get('code', '')
-
- if not description and function_code.strip():
- #print(f"Generating description for function '{function_name}'.")
- generated_description = func.description_writer(function_code)
- func.update_function(
- name=function_name,
- metadata={"description": generated_description}
- )
- print(f"Description for function '{function_name}' has been generated and updated.")
- return f"Description for function '{function_name}' has been generated and updated."
- elif not function_code.strip():
- print(f"Function '{function_name}' has no code to generate a description.")
- return f"Function '{function_name}' has no code to generate a description."
- else:
- print(f"Function '{function_name}' already has a non-empty description.")
- return f"Function '{function_name}' already has a non-empty description."
-
-@func.register_function(
- metadata={"description": "Scans all functions and generates descriptions for those lacking one"},
- dependencies=["ai_description_generator"]
-)
-def generate_missing_descriptions() -> None:
- all_functions = func.db.get_all_functions()
- missing_description_functions = [
- func_info['name'] for func_info in all_functions
- if not func_info.get('metadata', {}).get('description')
- ]
- if not missing_description_functions:
- print("All functions already have descriptions.")
- return
- print(f"Found {len(missing_description_functions)} function(s) without descriptions. Generating descriptions...")
- for function_name in missing_description_functions:
- func.ai_description_generator(function_name)
- print("Description generation process completed.")
-
-
-@func.register_function(
- metadata={"description": "Embeds an input using LiteLLM"},
- imports=["litellm"],
- key_dependencies=["openai_api_key"]
-)
-def embed_input(input_text: str, model: str = "text-embedding-ada-002",
- encoding_format: str = "float", dimensions: int = None,
- timeout: int = 600) -> list:
- from litellm import embedding
- import os
-
- # Set OpenAI API Key from environment variables
- os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')
-
- # Prepare the embedding request with optional parameters
- embedding_params = {
- "model": model,
- "input": [input_text],
- "encoding_format": encoding_format,
- "timeout": timeout
- }
-
- if dimensions:
- embedding_params["dimensions"] = dimensions
-
- # Call the LiteLLM embedding function
- response = embedding(**embedding_params)
-
- # Return the embedding from the response
- return response['data'][0]['embedding']
-
-
-@func.register_function(
- metadata={"description": "Embeds and updates a function's description if it exists"},
- dependencies=["embed_input"],
- imports=["os","csv"]
-)
-def embed_function_description(function: str) -> None:
- print(f"Embedding description for function: {function}")
- # Retrieve the function details from the database
- function_data = func.db.get_function(function)
- if not function_data:
- print(f"Function '{function}' not found in the database.")
- return
-
- description = function_data.get('metadata', {}).get('description', '').strip()
- if description:
- print(f"Embedding description for function '{function}'.")
- embedding = func.embed_input(description)
-
- # Check if 'function_embeddings.csv' exists, create it if not
- file_path = 'function_embeddings.csv'
- file_exists = os.path.isfile(file_path)
-
- # Create a list to store CSV data
- rows = []
-
- if file_exists:
- with open(file_path, mode='r') as file:
- reader = csv.reader(file)
- rows = list(reader)
-
- # Look for the function in the existing rows
- function_found = False
- for i, row in enumerate(rows):
- if row[0] == function: # function column is the first column
- rows[i][1] = str(embedding) # Update the embedding
- function_found = True
- print(f"Updated embedding for function '{function}'.")
-
- if not function_found:
- # Add a new row if the function is not found
- rows.append([function, str(embedding)])
- print(f"Added new function '{function}' with its embedding.")
-
- # Write back the data to the CSV file (create or update)
- with open(file_path, mode='w', newline='') as file:
- writer = csv.writer(file)
- writer.writerows(rows)
-
- print(f"Embedding for function '{function}' has been saved.")
- return embedding
- else:
- print(f"Function '{function}' has no description to embed.")
- return f"Function '{function}' has no description to embed."
-
-
-
-@func.register_function(
- metadata={"description": "Finds similar functions based on the provided description"},
- dependencies=["embed_input"],
- imports=["numpy", "csv", "sklearn","os"]
-)
-def find_similar_function(description: str, top_n: int = 3):
- import numpy as np
- from sklearn.metrics.pairwise import cosine_similarity
- # Step 1: Embed the input description
- #print(f"Embedding input description: {description}")
- input_embedding = func.embed_input(description)
-
- # Step 2: Load stored embeddings and descriptions from CSV
- file_path = 'function_embeddings.csv'
- stored_embeddings = []
- stored_functions = []
-
- if not os.path.isfile(file_path):
- print(f"No embeddings found in {file_path}.")
- return []
-
- with open(file_path, mode='r') as file:
- reader = csv.reader(file)
- for row in reader:
- stored_functions.append(row[0])
- stored_embeddings.append(np.fromstring(row[1].strip("[]"), sep=','))
-
- if not stored_embeddings:
- print("No embeddings stored.")
- return []
-
- # Step 3: Calculate cosine similarity between the input embedding and stored embeddings
- similarities = cosine_similarity([input_embedding], stored_embeddings)
-
- # Step 4: Sort stored functions by similarity
- sorted_indices = np.argsort(similarities[0])[::-1] # Sort in descending order
-
- # Step 5: Return the top N most similar functions
- similar_functions = [stored_functions[i] for i in sorted_indices[:top_n]]
-
- print(f"Top {top_n} similar functions: {similar_functions}")
- return similar_functions
-
-
-@func.register_function(
- metadata={"description": "Generates embeddings for functions missing from the CSV"},
- dependencies=["embed_function_description"],
- imports=["os", "csv"]
-)
-def generate_missing_embeddings() -> None:
- # Step 1: Retrieve all functions from the database
- all_functions = func.db.get_all_functions()
- all_function_names = [func_info['name'] for func_info in all_functions]
-
- # Step 2: Check if 'function_embeddings.csv' exists
- file_path = 'function_embeddings.csv'
- file_exists = os.path.isfile(file_path)
-
- # Read existing embeddings from CSV if the file exists
- embedded_functions = []
- if file_exists:
- with open(file_path, mode='r') as file:
- reader = csv.reader(file)
- embedded_functions = [row[0] for row in reader] # First column is the function name
-
- # Step 3: Find functions without embeddings
- missing_embeddings = [func_name for func_name in all_function_names if func_name not in embedded_functions]
-
- if not missing_embeddings:
- print("All functions already have embeddings.")
- return
-
- print(f"Found {len(missing_embeddings)} function(s) without embeddings. Generating embeddings...")
-
- # Step 4: Embed the functions that are missing
- for function_name in missing_embeddings:
- print(f"Embedding function: {function_name}")
- func.embed_function_description(function_name)
-
- print("Embedding generation process completed.")
-
-
-
-@func.register_function(
- metadata={"description": "Chooses a function to use"},
- dependencies=["get_all_functions","gpt_call"]
-)
-def choose_function(prompt: str) -> str:
- functions = func.get_all_functions()
- prompt = (
- f"Which functions are most relevant to the following input? It could be ones to use or look at as reference to build a new one:\n\n"
- f"{prompt}\n\n"
- f"Functions:{functions}"
- )
- choice = func.gpt_call(prompt)
- return {"functions":functions,"choice":choice}
\ No newline at end of file
diff --git a/babyagi/functionz/packs/default/default_functions.py b/babyagi/functionz/packs/default/default_functions.py
deleted file mode 100644
index 2f5d7bda..00000000
--- a/babyagi/functionz/packs/default/default_functions.py
+++ /dev/null
@@ -1,105 +0,0 @@
-# packs/default_functions.py
-
-from babyagi.functionz.core.framework import func
-from datetime import datetime
-from typing import Optional, Dict, Any, List
-
-@func.register_function()
-def execute_function_wrapper(function_name: str, *args, **kwargs):
- return func.execute_function(function_name, *args, **kwargs)
-
-@func.register_function(
- metadata={
- "description": "Dynamically adds a new function to the system with the provided code and metadata."
- },
- imports=["typing"]
-)
-def add_new_function(
- name: str,
- code: str,
- metadata: dict = None,
- imports: list = None,
- dependencies: list = None,
- key_dependencies: list = None,
- triggers: list = None
-) -> bool:
-
- try:
- func.registrar.add_function(
- name=name,
- code=code,
- metadata=metadata,
- imports=imports,
- dependencies=dependencies,
- key_dependencies=key_dependencies,
- triggers=triggers
- )
- #print(f"Function '{name}' added successfully.")
- return True
- except Exception as e:
- print(f"Error adding function '{name}': {str(e)}")
- return False
-
-
-@func.register_function()
-def function_added_or_updated(action=None, triggered_function_name=None):
- """
- Triggered whenever a function is added or updated.
- """
- print(f"Function '{triggered_function_name}' has been {action}.")
- function_data = func.get_function(triggered_function_name) if triggered_function_name else None
- if function_data:
- return triggered_function_name
- else:
- print(f"Function '{triggered_function_name}' not found in the database.")
- return None
-
-@func.register_function(
- metadata={"description": "Add a secret key to the database."},
- imports=["os"]
-)
-def add_key_wrapper(key_name: str, key_value: str):
- return func.add_key(key_name, key_value)
-
-@func.register_function(metadata={"description": "Get all versions of a given function."})
-def get_function_versions_wrapper(name: str):
- return func.get_function_versions(name)
-
-@func.register_function()
-def get_function_wrapper(name: str):
- return func.get_function(name)
-
-
-@func.register_function(metadata={"description": "Get all versions of a given function."})
-def get_all_functions_wrapper():
- return func.get_all_functions()
-
-@func.register_function(metadata={"description": "Activate a specific version of a function."})
-def activate_function_version_wrapper(name: str, version: int):
- return func.activate_function_version(name, version)
-
-@func.register_function(metadata={"description": "Display all registered functions and their metadata."})
-def display_functions_wrapper():
- return func.display()
-
-@func.register_function(
- metadata={"description": "Get logs for a specific function, optionally filtered by date."},
- imports=['datetime']
- )
-def get_logs_wrapper(function_name: str = None, start_date: datetime = None,
- end_date: datetime = None):
- return func.get_logs(function_name, start_date, end_date)
-
-@func.register_function(metadata={"description": "Add a trigger that executes a specific function when another function is executed."})
-def add_trigger_wrapper(triggered_function_name: str, triggering_function_name: Optional[str] = None):
- return func.add_trigger(triggered_function_name, triggering_function_name)
-
-
-@func.register_function(metadata={"description": "Get all secret keys stored."})
-def get_all_secret_keys():
- return func.get_all_secret_keys()
-
-
-@func.register_function(metadata={"description": "Get all imports."})
-def get_all_imports_wrapper():
- return func.get_all_imports()
\ No newline at end of file
diff --git a/babyagi/functionz/packs/default/function_calling_chat.py b/babyagi/functionz/packs/default/function_calling_chat.py
deleted file mode 100644
index 37de7d88..00000000
--- a/babyagi/functionz/packs/default/function_calling_chat.py
+++ /dev/null
@@ -1,165 +0,0 @@
-from functionz.core.framework import func
-import json
-import litellm
-
-# Assuming `func` is the registry from your framework
-# and `execute_function_wrapper` is already registered in the database.
-
-@func.register_function(
- metadata={
- "description": "A chat application that interacts with LiteLLM and executes selected functions from the database."
- },
- imports=["litellm", "json"],
- dependencies=["get_function_wrapper", "execute_function_wrapper"],
- key_dependencies=["OPENAI_API_KEY"] # Ensure this key is set in your environment
-)
-def chat_with_functions(chat_history, available_function_names) -> str:
- def map_python_type_to_json(python_type: str) -> dict:
- """
- Maps Python type annotations to JSON Schema types.
-
- Args:
- python_type (str): The Python type as a string.
-
- Returns:
- dict: The corresponding JSON Schema type with additional details if necessary.
- """
- type_mapping = {
- "str": {"type": "string"},
- "int": {"type": "integer"},
- "float": {"type": "number"},
- "bool": {"type": "boolean"},
- "list": {"type": "array", "items": {"type": "string"}}, # Assuming list of strings
- "dict": {"type": "object"},
- "Any": {"type": "string"} # Default to string for unsupported types
- }
- return type_mapping.get(python_type, {"type": "string"})
-
- # Enable verbose logging for LiteLLM
- litellm.set_verbose = True
-
- # Initialize chat context with system message
- chat_context = [
- {"role": "system", "content": "You are a helpful assistant."}
- ]
-
- # Validate and append chat history
- if not isinstance(chat_history, list):
- raise ValueError("chat_history must be a list of messages.")
-
- for message in chat_history:
- if not isinstance(message, dict):
- raise ValueError("Each message in chat_history must be a dictionary.")
- role = message.get('role')
- content = message.get('message')
- if role not in ['user', 'assistant', 'system']:
- raise ValueError("Message role must be 'user', 'assistant', or 'system'.")
- if not isinstance(content, str):
- raise ValueError("Message content must be a string.")
- chat_context.append({"role": role, "content": content})
-
- # Handle available_function_names input
- if isinstance(available_function_names, str):
- # Split the string by commas and strip whitespace
- available_function_names = [name.strip() for name in available_function_names.split(',') if name.strip()]
- elif isinstance(available_function_names, list):
- # Ensure all elements are strings and strip whitespace
- available_function_names = [name.strip() for name in available_function_names if isinstance(name, str) and name.strip()]
- else:
- raise ValueError("available_function_names must be a string or a list of strings.")
-
- if not available_function_names:
- raise ValueError("No valid function names provided in available_function_names.")
-
- # Fetch available functions from the database
- tools = []
- for func_name in available_function_names:
- # Retrieve function details using the get_function_wrapper
- function_data = get_function_wrapper(func_name)
- if function_data:
- # Construct the tool definition for LiteLLM
- tool = {
- "type": "function",
- "function": {
- "name": function_data['name'],
- "description": function_data['metadata']['description'],
- "parameters": {
- "type": "object",
- "properties": {},
- "required": []
- },
- },
- }
-
- # Map input_parameters to the tool's parameters
- for param in function_data.get('input_parameters', []):
- # Convert Python types to JSON Schema types
- json_schema = map_python_type_to_json(param['type'])
- tool['function']['parameters']['properties'][param['name']] = {
- **json_schema,
- "description": param.get('description', '')
- }
- if param.get('required', False):
- tool['function']['parameters']['required'].append(param['name'])
-
- tools.append(tool)
- else:
- # Handle the case where the function is not found
- raise ValueError(f"Function '{func_name}' not found in the database.")
-
-
- # Call LiteLLM's completion API with the user message and available tools
- response = litellm.completion(
- model="gpt-4-turbo",
- messages=chat_context,
- tools=tools,
- tool_choice="auto"
- )
-
- # Extract the message from the response
- response_message = response['choices'][0]['message']
-
- # Check if the model wants to call any functions
- tool_calls = response_message.get('tool_calls', [])
-
- # If there are function calls, execute them
- if tool_calls:
- # Append the assistant's message to the chat context
- chat_context.append(response_message)
-
- for tool_call in tool_calls:
- function_name = tool_call['function']['name']
- function_args = json.loads(tool_call['function']['arguments'])
- tool_call_id = tool_call['id'] # Extract the tool_call_id
-
- # Execute the function using execute_function_wrapper
- try:
- function_response = execute_function_wrapper(function_name, **function_args)
- except Exception as e:
- function_response = f"Error executing function '{function_name}': {str(e)}"
-
- # Ensure function_response is a string
- if not isinstance(function_response, str):
- function_response = json.dumps(function_response)
-
- # Append the function response to the chat context
- chat_context.append({
- "tool_call_id": tool_call_id, # Include the tool_call_id
- "role": "tool", # Use 'tool' as per LiteLLM's protocol
- "name": function_name,
- "content": function_response
- })
-
- # Call LiteLLM again with the updated context including function responses
- second_response = litellm.completion(
- model="gpt-4-turbo",
- messages=chat_context
- )
-
- # Extract and return the assistant's final response
- assistant_response = second_response['choices'][0]['message']['content']
- return assistant_response
- else:
- # If no functions are called, return the assistant's message directly
- assistant_response = response_message.get('content', '')
- return assistant_response
diff --git a/babyagi/functionz/packs/default/os.py b/babyagi/functionz/packs/default/os.py
deleted file mode 100644
index 8cf73bdc..00000000
--- a/babyagi/functionz/packs/default/os.py
+++ /dev/null
@@ -1,22 +0,0 @@
-@func.register_function(
- metadata={"description": "Returns the current directory and recursively lists all files and folders, excluding hidden files, folders (those starting with a '.'), and the '__pycache__' folder. The output omits the current directory prefix from file paths for readability."},
- imports=["os"]
-)
-def get_full_directory_contents_cleaned():
- current_directory = os.getcwd() # Get current working directory
- directory_structure = {}
-
- # Walk through the directory and its subdirectories
- for root, dirs, files in os.walk(current_directory):
- # Filter out hidden directories, '__pycache__', and hidden files
- dirs[:] = [d for d in dirs if not d.startswith('.') and d != '__pycache__']
- files = [f for f in files if not f.startswith('.')]
-
- # Remove the current directory path from the root
- relative_root = root.replace(current_directory, "").lstrip(os.sep)
- directory_structure[relative_root] = {
- "folders": dirs,
- "files": files
- }
-
- return {"current_directory": current_directory, "directory_structure": directory_structure}
diff --git a/babyagi/functionz/packs/drafts/code_writing_functions.py b/babyagi/functionz/packs/drafts/code_writing_functions.py
deleted file mode 100644
index 9b1a39d8..00000000
--- a/babyagi/functionz/packs/drafts/code_writing_functions.py
+++ /dev/null
@@ -1,540 +0,0 @@
-from functionz.core.framework import func
-
-@func.register_function(
- metadata={"description": "Checks if an existing function satisfies the user input"},
- dependencies=["gpt_call", "get_all_functions_wrapper"]
-)
-def check_existing_functions(user_input):
- import json
-
- while True:
- # Get all functions and their descriptions
- functions = get_all_functions_wrapper()
- function_descriptions = [
- {"name": f['name'], "description": f['metadata'].get('description', '')}
- for f in functions
- ]
-
- # Prepare the prompt
- prompt = f"""
-You are an expert software assistant. The user has provided the following request:
-
-"{user_input}"
-
-Below is a list of available functions with their descriptions:
-
-{function_descriptions}
-
-Determine if any of the existing functions perfectly fulfill the user's request. If so, return the name of the function.
-
-Provide your answer in the following JSON format:
-{{
- "function_found": true or false,
- "function_name": ""
-}}
-
-Examples:
-
-Example 1:
-User input: "Calculate the sum of two numbers"
-Functions: [{{"name": "add_numbers", "description": "Adds two numbers"}}]
-Response:
-{{
- "function_found": true,
- "function_name": "add_numbers"
-}}
-
-Example 2:
-User input: "Translate text to French"
-Functions: [{{"name": "add_numbers", "description": "Adds two numbers"}}]
-Response:
-{{
- "function_found": false,
- "function_name": null
-}}
-
-Now, analyze the user's request and provide the JSON response.
-"""
-
- response = gpt_call(prompt)
-
- # Try to parse the JSON response
- try:
- result = json.loads(response)
- if 'function_found' in result and isinstance(result['function_found'], bool) and \
- ('function_name' in result):
- return result
- else:
- raise ValueError("Invalid JSON structure")
- except Exception as e:
- # If parsing fails, retry
- continue
-
-@func.register_function(
- metadata={"description": "Breaks down the user task into smaller functions"},
- dependencies=["gpt_call"]
-)
-def break_down_task(user_input):
- import json
- while True:
- # Prepare the prompt with detailed context
- prompt = f"""
-You are an expert software assistant helping to break down a user's request into smaller functions for a microservice-inspired architecture. The system is designed to be modular, with each function being small and designed optimally for potential future reuse.
-
-When breaking down the task, consider the following:
-
-- Each function should be as small as possible and do one thing well.
-- Use existing functions where possible. You have access to functions such as 'gpt_call', 'find_similar_function', and others in our function database.
-- Functions can depend on each other. Use 'dependencies' to specify which functions a function relies on.
-- Functions should include appropriate 'imports' if external libraries are needed.
-- Provide the breakdown as a list of functions, where each function includes its 'name', 'description', 'input_parameters', 'output_parameters', 'dependencies', and 'code' (just a placeholder or brief description at this stage).
-- Make sure descriptions are detailed so an engineer could build it to spec.
-- Every sub function you create should be designed to be reusable by turning things into parameters, vs hardcoding them.
-
-User request:
-
-"{user_input}"
-
-Provide your answer in JSON format as a list of functions. Each function should have the following structure:
-
-{{
- "name": "function_name",
- "description": "Brief description of the function",
- "input_parameters": [{{"name": "param1", "type": "type1"}}, ...],
- "output_parameters": [{{"name": "output", "type": "type"}}, ...],
- "dependencies": ["dependency1", "dependency2", ...],
- "imports": ["import1", "import2", ...],
- "code": "Placeholder or brief description"
-}}
-
-Example:
-
-[
- {{
- "name": "process_data",
- "description": "Processes input data",
- "input_parameters": [{{"name": "data", "type": "str"}}],
- "output_parameters": [{{"name": "processed_data", "type": "str"}}],
- "dependencies": [],
- "imports": [],
- "code": "Placeholder for process_data function"
- }},
- {{
- "name": "analyze_data",
- "description": "Analyzes processed data",
- "input_parameters": [{{"name": "processed_data", "type": "str"}}],
- "output_parameters": [{{"name": "analysis_result", "type": "str"}}],
- "dependencies": ["process_data"],
- "imports": [],
- "code": "Placeholder for analyze_data function"
- }}
-]
-
-Now, provide the breakdown for the user's request.
-"""
-
- response = gpt_call(prompt)
-
- # Try to parse the JSON response
- try:
- functions = json.loads(response)
- # Basic validation of the structure
- if isinstance(functions, list) and all('name' in func and 'description' in func for func in functions):
- return functions
- else:
- raise ValueError("Invalid JSON structure")
- except Exception as e:
- # If parsing fails, retry
- continue
-
-@func.register_function(
- metadata={"description": "Decides if imports or external APIs are needed"},
- dependencies=["gpt_call", "get_all_functions_wrapper"]
-)
-def decide_imports_and_apis(context):
- import json
- while True:
- # Get all available functions and their imports
- all_functions = get_all_functions_wrapper()
- existing_imports = set()
- for func in all_functions:
- existing_imports.update(func.get('imports', []))
-
- # Prepare the prompt
- prompt = f"""
-You are an expert software assistant helping to decide what imports and external APIs are needed for a set of functions based on the context provided.
-
-Context:
-
-{context}
-
-Existing standard Python imports:
-
-{list(existing_imports)}
-
-Determine the libraries (imports) and external APIs needed for these functions. Separate standard Python libraries from external libraries or APIs.
-
-Provide your answer in the following JSON format:
-
-{{
- "standard_imports": ["import1", "import2", ...],
- "external_imports": ["external_import1", "external_import2", ...],
- "external_apis": ["api1", "api2", ...],
- "documentation_needed": [
- {{"name": "external_import1", "type": "import" or "api"}},
- ...
- ]
-}}
-
-Note: 'documentation_needed' should include any external imports or APIs for which documentation should be looked up.
-
-Example:
-
-{{
- "standard_imports": ["os", "json"],
- "external_imports": ["requests"],
- "external_apis": ["SerpAPI"],
- "documentation_needed": [
- {{"name": "requests", "type": "import"}},
- {{"name": "SerpAPI", "type": "api"}}
- ]
-}}
-
-Now, analyze the context and provide the JSON response.
-"""
-
- response = gpt_call(prompt)
-
- # Try to parse the JSON response
- try:
- result = json.loads(response)
- # Basic validation of the structure
- if all(key in result for key in ['standard_imports', 'external_imports', 'external_apis', 'documentation_needed']):
- return result
- else:
- raise ValueError("Invalid JSON structure")
- except Exception as e:
- # If parsing fails, retry
- continue
-
-@func.register_function(
- metadata={"description": "Gets functions that depend on a given function"},
- dependencies=["get_all_functions_wrapper"]
-)
-def get_functions_that_depend_on(function_name):
- all_functions = get_all_functions_wrapper()
- dependent_functions = []
- for function in all_functions:
- if function_name in function.get('dependencies', []):
- dependent_functions.append(function['name'])
- return dependent_functions
-
-
-@func.register_function(
- metadata={"description": "Generates the function code using LLM"},
- dependencies=["gpt_call", "get_function_wrapper", "get_functions_that_depend_on", "get_all_functions_wrapper"]
-)
-def generate_function_code(function, context):
- while True:
-
- print("\033[1;32mGenerating code for function: ", function["name"], "\033[0m")
- # Gather dependent functions and their code
- dependencies = function.get('dependencies', [])
- dependency_code = ''
- for dep in dependencies:
- dep_function = get_function_wrapper(dep)
- if dep_function:
- dependency_code += f"\n# Code for dependency function '{dep}':\n{dep_function['code']}\n"
-
- # Gather functions that depend on the same imports
- imports = function.get('imports', [])
- functions_with_same_imports = []
- all_functions = get_all_functions_wrapper()
- for func_with_imports in all_functions:
- if set(func_with_imports.get('imports', [])) & set(imports):
- functions_with_same_imports.append(func_with_imports)
-
- similar_imports_functions_code = ''
- for func_with_imports in functions_with_same_imports:
- similar_imports_functions_code += f"\n# Code for function '{func_with_imports['name']}' that uses similar imports:\n{func_with_imports['code']}\n"
-
- # Prepare the prompt
- prompt = f"""
-You are an expert Python programmer. Your task is to write detailed and working code for the following function based on the context provided. Do not provide placeholder code, but rather do your best like you are the best senior engineer in the world and provide the best code possible. DO NOT PROVIDE PLACEHOLDER CODE.
-
-Function details:
-
-Name: {function['name']}
-Description: {function['description']}
-Input parameters: {function['input_parameters']}
-Output parameters: {function['output_parameters']}
-Dependencies: {function['dependencies']}
-Imports: {function['imports']}
-
-Overall context:
-
-{context}
-
-Dependency code:
-
-{dependency_code}
-
-Code from functions with similar imports:
-
-{similar_imports_functions_code}
-
-Please provide the function details in JSON format, following this structure:
-
-{{
- "function_name": "",
- "metadata": {{
- "description": "",
- "input_parameters": {function['input_parameters']},
- "output_parameters": {function['output_parameters']}
- }},
- "code": "",
- "imports": {function['imports']},
- "dependencies": {function['dependencies']},
- "key_dependencies": [],
- "triggers": []
-}}
-
-**Example JSON Output:**
-
-{{
- "function_name": "example_function",
- "metadata": {{
- "description": "An example function.",
- "input_parameters": [{{"name": "param1", "type": "str"}}],
- "output_parameters": [{{"name": "result", "type": "str"}}]
- }},
- "code": "",
- "imports": ["os"],
- "dependencies": [],
- "key_dependencies": [],
- "triggers": []
-}}
-
-Provide the JSON output only, without any additional text. Do not provide placeholder code, but write complete code that is ready to run and provide the expected output.
-
-Now, please provide the JSON output for the function '{function['name']}'.
-"""
-
- response = gpt_call(prompt)
-
- try:
- # Parse the JSON response
- import json
- function_data = json.loads(response)
-
- # Return the parsed function data
- return function_data
- except json.JSONDecodeError as e:
- # If parsing fails, retry
- print(f"JSON decoding error: {str(e)}")
- continue
- except Exception as e:
- print(f"Error processing function data: {str(e)}")
- return None
-
-
-@func.register_function(
- metadata={"description": "Creates a new function if similar functions are not sufficient"},
- dependencies=["decide_imports_and_apis", "generate_function_code","add_new_function"]
-)
-def create_function(function, context):
- # Decide imports and APIs
- imports_and_apis = decide_imports_and_apis(context)
- function['imports'] = imports_and_apis.get('standard_imports', []) + imports_and_apis.get('external_imports', [])
-
- # Update context with imports and APIs
- context.update({'imports_and_apis': imports_and_apis})
-
- # Generate function code
- function_data = generate_function_code(function, context)
-
- if function_data:
- # Register the function using the parsed JSON data
- add_new_function(
- name=function_data['function_name'],
- code=function_data['code'],
- metadata=function_data['metadata'],
- imports=function_data.get('imports', []),
- dependencies=function_data.get('dependencies', []),
- key_dependencies=function_data.get('key_dependencies', []),
- triggers=function_data.get('triggers', [])
- )
-
- #print(f"Function '{function_data['function_name']}' registered successfully.")
-
- return {
- 'name': function_data['function_name'],
- 'code': function_data['code'],
- 'metadata': function_data['metadata'],
- 'imports': function_data.get('imports', []),
- 'dependencies': function_data.get('dependencies', []),
- 'key_dependencies': function_data.get('key_dependencies', []),
- 'triggers': function_data.get('triggers', [])
- }
- else:
- print("Failed to generate function code.")
- return None
-
-
-
-@func.register_function(
- metadata={"description": "Generates the required functions based on the breakdown"},
- dependencies=["find_similar_function", "create_function", "get_function_wrapper"]
-)
-def generate_functions(function_breakdown, context):
- for function in function_breakdown:
- function_name = function['name']
- # Find similar functions
- similar_functions = find_similar_function(function['description'])
- function_found = False
- for similar_function_name in similar_functions:
- similar_function = get_function_wrapper(similar_function_name)
- if similar_function and similar_function['metadata'].get('description', '') == function['description']:
- function_found = True
- break
- if not function_found:
- # Combine context for this function
- function_context = context.copy()
- function_context.update({'function': function})
- create_function(function, function_context)
-
-@func.register_function(
- metadata={"description": "Runs the final function to produce the output for the user"},
- dependencies=["func"]
-)
-def run_final_function(function_name, *args, **kwargs):
- result = func.execute_function(function_name, *args, **kwargs)
- return result
-
-@func.register_function(
- metadata={"description": "Extracts parameters from user input for a given function"},
- dependencies=["gpt_call", "get_function_wrapper"]
-)
-def extract_function_parameters(user_input, function_name):
- import json
- # Get the function code and parameters
- function = get_function_wrapper(function_name)
- if not function:
- print(f"Function '{function_name}' not found.")
- return None
-
- # Prepare the prompt to convert user input into function parameters
- while True:
- prompt = f"""
-You are an expert assistant. The user wants to execute the following function:
-
-Function code:
-{function['code']}
-
-Function description:
-{function['metadata'].get('description', '')}
-
-Function parameters:
-{function['metadata'].get('input_parameters', [])}
-
-The user has provided the following input:
-"{user_input}"
-
-Your task is to extract the required parameters from the user's input and provide them in JSON format that matches the function's parameters.
-
-Provide your answer in the following JSON format:
-{{
- "parameters": {{
- "param1": value1,
- "param2": value2,
- ...
- }}
-}}
-
-Ensure that the parameters match the function's required input parameters.
-
-Examples:
-
-Example 1:
-
-Function code:
-def add_numbers(a, b):
- return a + b
-
-Function parameters:
-[{{"name": "a", "type": "int"}}, {{"name": "b", "type": "int"}}]
-
-User input: "Add 5 and 3"
-
-Response:
-{{
- "parameters": {{
- "a": 5,
- "b": 3
- }}
-}}
-
-Example 2:
-
-Function code:
-def greet_user(name):
- return f"Hello, {{name}}!"
-
-Function parameters:
-[{{"name": "name", "type": "str"}}]
-
-User input: "Say hello to Alice"
-
-Response:
-{{
- "parameters": {{
- "name": "Alice"
- }}
-}}
-
-Now, using the function provided and the user's input, extract the parameters and provide the JSON response.
-"""
- response = gpt_call(prompt)
-
- # Try to parse the JSON response
- try:
- result = json.loads(response)
- if 'parameters' in result and isinstance(result['parameters'], dict):
- return result['parameters']
- else:
- raise ValueError("Invalid JSON structure")
- except Exception as e:
- # If parsing fails, retry
- continue
-
-@func.register_function(
- metadata={"description": "Main function to process user input and generate the required functions"},
- dependencies=["check_existing_functions", "break_down_task", "generate_functions", "run_final_function", "extract_function_parameters"]
-)
-def process_user_input(user_input):
- # First, check if an existing function satisfies the user input
- print("\033[1;95mProcessing user input: ", user_input, "\033[0m")
- result = check_existing_functions(user_input)
- if result['function_found']:
- function_name = result['function_name']
- else:
- # Break down the task into functions
- function_breakdown = break_down_task(user_input)
- # Context to be passed around
- context = {'user_input': user_input, 'function_breakdown': function_breakdown}
- # Generate the required functions
- generate_functions(function_breakdown, context)
- # Assume the main function is the first one in the breakdown
- function_name = function_breakdown[0]['name']
-
- # Extract parameters from user input for the function
- parameters = extract_function_parameters(user_input, function_name)
- if parameters is None:
- print("Failed to extract parameters from user input.")
- return None
-
- # Call the function with the parameters
- output = run_final_function(function_name, **parameters)
- return output
-
-
diff --git a/babyagi/functionz/packs/drafts/self_build.py b/babyagi/functionz/packs/drafts/self_build.py
deleted file mode 100644
index 185bb24f..00000000
--- a/babyagi/functionz/packs/drafts/self_build.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# self_build.py
-
-from functionz.core.framework import func
-import json
-
-@func.register_function(
- metadata={"description": "Generates queries based on user description"},
- dependencies=["gpt_call"],
- imports=["json"]
-)
-def generate_queries(user_description, X=3, max_retries=3):
- """
- Generates X distinct queries that require action based on the user description using gpt_call.
-
- Args:
- user_description (str): Description of the user or their needs.
- X (int, optional): Number of queries to generate. Defaults to 3.
- max_retries (int, optional): Maximum number of retries for generating valid queries. Defaults to 3.
-
- Returns:
- list: A list of generated queries.
-
- Raises:
- ValueError: If unable to generate valid queries within the retry limit.
- """
- prompt = f"""
-You are an AI assistant. Based on the following user description, generate {X} distinct queries that such a user might ask:
-
-User Description:
-"{user_description}"
-
-Provide the queries in JSON format as a list:
-
-[
- "Query 1",
- "Query 2",
- ...
-]
-
-Ensure the queries are diverse, relevant to the user description, and represent realistic questions that this user might ask. Make requests that require action, such as using tools and APIs, which you should specify in the request. Based on the user description, guess what types of tools they use and specify them in the query.
-"""
-
- errors = [] # To collect error messages from each attempt
-
- for attempt in range(1, max_retries + 1):
- response = gpt_call(prompt)
- try:
- queries = json.loads(response)
- if isinstance(queries, list) and len(queries) == X and all(isinstance(q, str) for q in queries):
- return queries
- else:
- error_message = (
- f"Attempt {attempt}: Invalid JSON structure or incorrect number of queries. "
- f"Expected {X} string queries, but received: {response}"
- )
- errors.append(error_message)
- except json.JSONDecodeError as e:
- error_message = (
- f"Attempt {attempt}: JSON decoding failed with error: {str(e)}. "
- f"Response received: {response}"
- )
- errors.append(error_message)
- except Exception as e:
- error_message = (
- f"Attempt {attempt}: An unexpected error occurred: {str(e)}. "
- f"Response received: {response}"
- )
- errors.append(error_message)
-
- # After all attempts, raise an error with all collected messages
- full_error_message = " | ".join(errors)
- raise ValueError(f"Failed to generate {X} valid queries after {max_retries} attempts. Errors: {full_error_message}")
-
-
-@func.register_function(
- metadata={"description": "Processes generated queries based on user description"},
- dependencies=["generate_queries", "process_user_input"],
- imports=["json"]
-)
-def self_build(user_description, X=3):
- """
- Generates queries based on the user description and processes each query.
-
- Args:
- user_description (str): Description of the user or their needs.
- X (int, optional): Number of queries to generate and process. Defaults to 3.
-
- Returns:
- list: A list of dictionaries containing each query and its corresponding output.
-
- Raises:
- ValueError: If query generation fails.
- """
- try:
-
- print("\033[1;33mUser Description: ", user_description, "\033[0m")
- # Generate queries
- queries = generate_queries(user_description, X)
- except ValueError as e:
- # Log the error message for debugging
- print(f"Error in generate_queries: {str(e)}")
- return []
-
- print("\033[1;34mQueries generated by self_build: ", queries, "\033[0m")
- results = []
- for idx, query in enumerate(queries, start=1):
- try:
- output = process_user_input(query)
- results.append({'query': query, 'output': output})
- except Exception as e:
- # Log the error message for debugging
- print(f"Error processing query {idx} ('{query}'): {str(e)}")
- results.append({'query': query, 'output': None, 'error': str(e)})
-
- return results
diff --git a/babyagi/functionz/packs/drafts/user_db.py b/babyagi/functionz/packs/drafts/user_db.py
deleted file mode 100644
index ff0f4e91..00000000
--- a/babyagi/functionz/packs/drafts/user_db.py
+++ /dev/null
@@ -1,447 +0,0 @@
-# packs/user_db.py
-
-from PythonFunc.core.framework import func
-
-@func.register_function(
- metadata={"description": "Base UserDB class for database operations."},
- imports=["sqlalchemy", "contextlib"]
-)
-def get_user_db_class():
- from sqlalchemy import create_engine, Column, Integer, String, MetaData
- from sqlalchemy.ext.declarative import declarative_base
- from sqlalchemy.orm import sessionmaker
- from contextlib import contextmanager
- from sqlalchemy.exc import SQLAlchemyError
-
- class UserDB:
- def __init__(self, db_url='sqlite:///user_db.sqlite'):
- self.engine = create_engine(db_url)
- self.Session = sessionmaker(bind=self.engine)
- self.metadata = MetaData()
- self.Base = declarative_base(metadata=self.metadata)
-
- @contextmanager
- def session_scope(self):
- session = self.Session()
- try:
- yield session
- session.commit()
- except SQLAlchemyError as e:
- session.rollback()
- raise e
- finally:
- session.close()
-
- return UserDB.__name__ # Return the name of the class instead of the class itself
-
-@func.register_function(
- metadata={"description": "Create a new database."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy"]
-)
-def create_database(db_name: str, db_type: str = 'sqlite', **kwargs):
- from sqlalchemy import create_engine, MetaData
-
- if db_type == 'sqlite':
- db_url = f'sqlite:///{db_name}.sqlite'
- elif db_type == 'postgresql':
- db_url = f'postgresql://{kwargs.get("user")}:{kwargs.get("password")}@{kwargs.get("host", "localhost")}:{kwargs.get("port", 5432)}/{db_name}'
- elif db_type == 'mysql':
- db_url = f'mysql+pymysql://{kwargs.get("user")}:{kwargs.get("password")}@{kwargs.get("host", "localhost")}:{kwargs.get("port", 3306)}/{db_name}'
- else:
- raise ValueError(f"Unsupported database type: {db_type}")
-
- UserDB_name = func.get_user_db_class()
- # Reconstruct the UserDB class
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
-
- user_db = UserDB(db_url) # Pass db_url here
-
- new_engine = create_engine(db_url)
- user_db.metadata.create_all(new_engine)
- return f"Database '{db_name}' created successfully."
-
-
-@func.register_function(
- metadata={"description": "List all SQLite databases."},
- dependencies=["get_user_db_class"],
- imports=["os", "sqlalchemy"]
-)
-def list_databases():
- import os
- from sqlalchemy import create_engine, MetaData
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- # This function doesn't actually use UserDB, but we include it for consistency
- return [f for f in os.listdir() if f.endswith('.sqlite')]
-
-@func.register_function(
- metadata={"description": "Delete a database."},
- dependencies=["get_user_db_class"],
- imports=["os", "sqlalchemy"]
-)
-def delete_database(db_name: str, db_type: str = 'sqlite', **kwargs):
- import os
- from sqlalchemy import create_engine, MetaData
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- # This function doesn't actually use UserDB, but we include it for consistency
- if db_type == 'sqlite':
- os.remove(f'{db_name}.sqlite')
- return f"Database '{db_name}' deleted successfully."
- else:
- raise NotImplementedError(f"Deleting {db_type} databases is not implemented yet.")
-
-@func.register_function(
- metadata={"description": "Create a new table in the database."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy", "json"] # Added 'json' to imports
-)
-def create_table(db_name: str, table_name: str, columns: str):
- from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer, Float, Boolean, DateTime, LargeBinary
- import json # Imported json within the function
-
-
- try:
- columns = json.loads(columns)
- print("Parsed columns:", columns) # Debugging statement
- except json.JSONDecodeError as e:
- return f"Invalid JSON for columns: {e}"
-
- def get_column_type(type_name):
- type_map = {
- 'string': String,
- 'integer': Integer,
- 'float': Float,
- 'boolean': Boolean,
- 'datetime': DateTime,
- 'binary': LargeBinary,
- 'embedding': LargeBinary # We'll use LargeBinary for embeddings
- }
- return type_map.get(type_name.lower(), String) # Default to String if type not found
-
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData(),
- })
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
-
- # Create the table
- table = Table(
- table_name,
- user_db.metadata,
- Column('id', Integer, primary_key=True),
- *(Column(col['name'], get_column_type(col['type'])) for col in columns)
- )
-
- # Create the table in the database
- table.create(user_db.engine, checkfirst=True)
-
- return f"Table '{table_name}' created successfully in database '{db_name}'."
-
-
-
-@func.register_function(
- metadata={"description": "List all tables in a database."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy"]
-)
-def list_tables(db_name: str):
- from sqlalchemy import create_engine, MetaData
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
- return [table.name for table in user_db.metadata.tables.values()]
-
-@func.register_function(
- metadata={"description": "Get details of a specific table."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy"]
-)
-def get_table(db_name: str, table_name: str):
- from sqlalchemy import create_engine, MetaData, Table
- from sqlalchemy.exc import NoSuchTableError
-
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
-
- try:
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
-
- if table_name in user_db.metadata.tables:
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- return {
- "name": table.name,
- "columns": [{"name": column.name, "type": str(column.type)} for column in table.columns]
- }
- else:
- return f"Table '{table_name}' not found in database '{db_name}'."
- except NoSuchTableError:
- return f"Table '{table_name}' not found in database '{db_name}'."
- except Exception as e:
- return f"Error getting table details: {str(e)}"
-
-@func.register_function(
- metadata={"description": "Update a table by adding new columns."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy", "json"] # Added 'json' to imports
-)
-def update_table(db_name: str, table_name: str, new_columns: str):
- from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer, Float, Boolean, DateTime, LargeBinary
- from sqlalchemy.schema import CreateTable
- import json # Imported json within the function
-
- try:
- new_columns = json.loads(new_columns)
- print("Parsed columns:", new_columns) # Debugging statement
- except json.JSONDecodeError as e:
- return f"Invalid JSON for columns: {e}"
-
- def get_column_type(type_name):
- type_map = {
- 'string': String,
- 'integer': Integer,
- 'float': Float,
- 'boolean': Boolean,
- 'datetime': DateTime,
- 'binary': LargeBinary,
- 'embedding': LargeBinary # We'll use LargeBinary for embeddings
- }
- return type_map.get(type_name.lower(), String) # Default to String if type not found
-
-
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
-
- try:
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
-
- if table_name not in user_db.metadata.tables:
- return f"Table '{table_name}' not found in database '{db_name}'."
-
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- existing_columns = set(column.name for column in table.columns)
-
- for col in new_columns:
- if col['name'] not in existing_columns:
- new_column = Column(col['name'], get_column_type(col['type']))
- # Generate the SQL statement to add the new column
- alter_stmt = f'ALTER TABLE {table_name} ADD COLUMN {new_column.name} {new_column.type}'
- user_db.engine.execute(alter_stmt)
-
- # Refresh the table metadata
- user_db.metadata.clear()
- user_db.metadata.reflect(user_db.engine)
-
- return f"Table '{table_name}' updated successfully in database '{db_name}'."
-
- except Exception as e:
- return f"An error occurred while updating the table: {e}"
-
-
-@func.register_function(
- metadata={"description": "Delete a table from the database."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy"]
-)
-def delete_table(db_name: str, table_name: str):
- from sqlalchemy import create_engine, MetaData, Table
- from sqlalchemy.exc import NoSuchTableError
-
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
-
- try:
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
-
- if table_name in user_db.metadata.tables:
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- table.drop(user_db.engine)
- user_db.metadata.remove(table)
- return f"Table '{table_name}' deleted successfully from database '{db_name}'."
- else:
- return f"Table '{table_name}' not found in database '{db_name}'."
- except NoSuchTableError:
- return f"Table '{table_name}' not found in database '{db_name}'."
- except Exception as e:
- return f"Error deleting table: {str(e)}"
-
-
-@func.register_function(
- metadata={"description": "Create a new record in a table."},
- dependencies=["get_user_db_class", "convert_value"],
- imports=["sqlalchemy", "json"]
-)
-def create_record(db_name: str, table_name: str, data: list):
- from sqlalchemy import create_engine, MetaData, Table, String
- from sqlalchemy.orm import sessionmaker
- import json
-
- if not isinstance(data_dict, dict):
- return "Error: Data must be a JSON object"
-
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- Session = sessionmaker(bind=user_db.engine)
-
- # Get column types
- column_types = {c.name: c.type for c in table.columns}
-
- # Convert input data to appropriate types
- converted_data = {key: func.convert_value(value, column_types.get(key, String)) for key, value in data.items()}
-
- try:
- with Session() as session:
- ins = table.insert().values(**converted_data)
- session.execute(ins)
- session.commit()
- return f"Record created in table '{table_name}' of database '{db_name}'."
- except Exception as e:
- return f"Error creating record: {str(e)}"
-
-def read_records(db_name: str, table_name: str, filters: dict = None):
- from sqlalchemy import create_engine, MetaData, Table
- from sqlalchemy.orm import sessionmaker
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- Session = sessionmaker(bind=user_db.engine)
- with Session() as session:
- query = session.query(table)
- if filters:
- query = query.filter_by(**filters)
- return [dict(row) for row in query.all()]
-
-@func.register_function(
- metadata={"description": "Update a record in a table."},
- dependencies=["get_user_db_class", "convert_value"],
- imports=["sqlalchemy", "json"]
-)
-def update_record(db_name: str, table_name: str, record_id: int, data: json):
- from sqlalchemy import create_engine, MetaData, Table, String
- from sqlalchemy.orm import sessionmaker
- import json
-
- if not isinstance(data_dict, dict):
- return "Error: Data must be a JSON object"
-
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- Session = sessionmaker(bind=user_db.engine)
-
- # Get column types
- column_types = {c.name: c.type for c in table.columns}
-
- # Convert input data to appropriate types
- converted_data = {key: func.convert_value(value, column_types.get(key, String)) for key, value in data.items()}
-
- try:
- with Session() as session:
- update = table.update().where(table.c.id == record_id).values(**converted_data)
- result = session.execute(update)
- session.commit()
- if result.rowcount:
- return f"Record {record_id} in table '{table_name}' of database '{db_name}' updated successfully."
- return f"Record {record_id} not found in table '{table_name}' of database '{db_name}'."
- except Exception as e:
- return f"Error updating record: {str(e)}"
-
-@func.register_function(
- metadata={"description": "Delete a record from a table."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy"]
-)
-def delete_record(db_name: str, table_name: str, record_id: int):
- from sqlalchemy import create_engine, MetaData, Table
- from sqlalchemy.orm import sessionmaker
- UserDB_name = func.get_user_db_class()
- UserDB = type(UserDB_name, (), {
- '__init__': lambda self, db_url: setattr(self, 'engine', create_engine(db_url)),
- 'metadata': MetaData()
- })
- user_db = UserDB(f'sqlite:///{db_name}.sqlite')
- user_db.metadata.reflect(user_db.engine)
- table = Table(table_name, user_db.metadata, autoload_with=user_db.engine)
- Session = sessionmaker(bind=user_db.engine)
- with Session() as session:
- delete = table.delete().where(table.c.id == record_id)
- result = session.execute(delete)
- session.commit()
- if result.rowcount:
- return f"Record {record_id} in table '{table_name}' of database '{db_name}' deleted successfully."
- return f"Record {record_id} not found in table '{table_name}' of database '{db_name}'."
-
-
-@func.register_function(
- metadata={"description": "Convert value to specified SQLAlchemy type"},
- imports=["sqlalchemy", "json", "datetime"]
-)
-def convert_value(value, target_type):
- from sqlalchemy import Boolean, DateTime, LargeBinary, Integer, Float
- import json
- from datetime import datetime
-
- if isinstance(value, str):
- if target_type == Boolean:
- return value.lower() in ('true', 'yes', '1', 'on')
- elif target_type == DateTime:
- return datetime.fromisoformat(value)
- elif target_type == LargeBinary:
- try:
- # Assume it's a JSON array for embeddings
- return json.dumps(json.loads(value)).encode('utf-8')
- except json.JSONDecodeError:
- # If not JSON, treat as regular binary data
- return value.encode('utf-8')
- elif target_type in (Integer, Float):
- return target_type(value)
- return value # Return as-is for String or if already correct type
-
-@func.register_function(
- metadata={"description": "Create a new table in the database."},
- dependencies=["get_user_db_class"],
- imports=["sqlalchemy"]
-)
\ No newline at end of file
diff --git a/babyagi/functionz/packs/plugins/airtable.py b/babyagi/functionz/packs/plugins/airtable.py
deleted file mode 100644
index 08e2e479..00000000
--- a/babyagi/functionz/packs/plugins/airtable.py
+++ /dev/null
@@ -1,203 +0,0 @@
-from functionz import func
-
-# Initialize the Airtable Table instance
-@func.register_function(
- metadata={"description": "Initialize Airtable table instance with access token, base ID, and table name."},
- key_dependencies=["airtable_access_token"],
- imports=["pyairtable"]
-)
-def init_airtable(base_id, table_name):
- """
- Initialize the Airtable Table instance.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :return: Airtable Table instance
- """
- api_token = globals()["airtable_access_token"]
- from pyairtable import Table
- return Table(api_token, base_id, table_name)
-
-
-# Create a single record in a given Airtable table
-@func.register_function(
- metadata={"description": "Create a new record in a specific Airtable table."},
- dependencies=["init_airtable"]
-)
-def create_record(base_id, table_name, record_data):
- """
- Create a new record in the specified Airtable table.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param record_data: Dictionary containing record fields and values
- :return: The newly created record
- """
- table = init_airtable(base_id, table_name)
- return table.create(record_data)
-
-
-# Retrieve a single record by its ID
-@func.register_function(
- metadata={"description": "Retrieve a specific record from Airtable using its record ID."},
- dependencies=["init_airtable"]
-)
-def get_record_by_id(base_id, table_name, record_id):
- """
- Retrieve a record by its unique ID from the specified Airtable table.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param record_id: Unique record ID in Airtable
- :return: The record data as a dictionary
- """
- table = init_airtable(base_id, table_name)
- return table.get(record_id)
-
-
-# Update an existing record by its ID
-@func.register_function(
- metadata={"description": "Update a record in Airtable using its ID and new field values."},
- dependencies=["init_airtable"]
-)
-def update_record(base_id, table_name, record_id, updated_fields):
- """
- Update a record in Airtable with new values for specified fields.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param record_id: Unique record ID in Airtable
- :param updated_fields: Dictionary with updated field values
- :return: The updated record data as a dictionary
- """
- table = init_airtable(base_id, table_name)
- return table.update(record_id, updated_fields)
-
-
-# Delete a record by its ID
-@func.register_function(
- metadata={"description": "Delete a specific record from an Airtable table."},
- dependencies=["init_airtable"]
-)
-def delete_record(base_id, table_name, record_id):
- """
- Delete a record from Airtable using its unique ID.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param record_id: Unique record ID in Airtable
- :return: Deletion confirmation message
- """
- table = init_airtable(base_id, table_name)
- return table.delete(record_id)
-
-
-# Retrieve all records from a table
-@func.register_function(
- metadata={"description": "Retrieve all records from a specific Airtable table."},
- dependencies=["init_airtable"]
-)
-def get_all_records(base_id, table_name, max_records=100, sort_by=None):
- """
- Get all records from the specified table, with optional sorting.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param max_records: Maximum number of records to retrieve
- :param sort_by: Optional list of fields to sort the records by
- :return: List of all records
- """
- table = init_airtable(base_id, table_name)
- return table.all(max_records=max_records, sort=sort_by)
-
-
-# Upsert multiple records into a table based on unique fields
-@func.register_function(
- metadata={"description": "Upsert (create or update) multiple records into a table using unique field identifiers."},
- dependencies=["init_airtable"]
-)
-def batch_upsert_records(base_id, table_name, records, key_fields):
- """
- Upsert multiple records into the specified table.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param records: List of records to be upserted
- :param key_fields: List of fields to use as unique keys
- :return: List of created or updated records
- """
- table = init_airtable(base_id, table_name)
- return table.batch_upsert(records, key_fields=key_fields)
-
-
-# Batch create multiple records in a table
-@func.register_function(
- metadata={"description": "Create multiple records in a table using batch operations."},
- dependencies=["init_airtable"]
-)
-def batch_create_records(base_id, table_name, records):
- """
- Create multiple records in the specified table.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param records: List of records to be created
- :return: List of created records
- """
- table = init_airtable(base_id, table_name)
- return table.batch_create(records)
-
-
-# Batch delete multiple records from a table
-@func.register_function(
- metadata={"description": "Delete multiple records in a table using batch operations."},
- dependencies=["init_airtable"]
-)
-def batch_delete_records(base_id, table_name, record_ids):
- """
- Batch delete records using their unique IDs.
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param record_ids: List of record IDs to be deleted
- :return: Confirmation messages for deleted records
- """
- table = init_airtable(base_id, table_name)
- return table.batch_delete(record_ids)
-
-
-
-from functionz import func
-
-@func.register_function(
- metadata={"description": "Fetch a dynamic number of rows from Airtable based on a flexible search query."},
- dependencies=["init_airtable"],
- imports=["pyairtable"]
-)
-def get_dynamic_records(base_id, table_name, max_records=100, search_query=None, sort_by=None, fields=None, view=None, page_size=100):
- """
- Fetch a dynamic number of records from an Airtable table based on a custom query.
-
- :param base_id: ID of the Airtable base
- :param table_name: Name of the table within the base
- :param max_records: Maximum number of records to retrieve
- :param search_query: Dictionary of field-value pairs to match (e.g., {"Name": "Alice", "Age": 30})
- :param sort_by: List of fields to sort the records by (e.g., ["Name", "-Age"])
- :param fields: List of specific fields to retrieve (e.g., ["Name", "Age"])
- :param view: View ID or name to filter the records by
- :param page_size: Number of records per page request
- :return: List of matching records
- """
- from pyairtable.formulas import match
- table = init_airtable(base_id, table_name)
-
- # Construct a formula using the match function if search_query is provided
- formula = None
- if search_query:
- from pyairtable.formulas import match
- formula = match(search_query)
-
- # Use iterate to handle large datasets if max_records is set higher than page_size
- records = table.iterate(
- formula=formula,
- sort=sort_by,
- fields=fields,
- view=view,
- page_size=page_size,
- max_records=max_records
- )
-
- # Collect results from the generator into a list
- return list(records)
-
diff --git a/babyagi/functionz/packs/plugins/augie.py b/babyagi/functionz/packs/plugins/augie.py
deleted file mode 100644
index ff2bca66..00000000
--- a/babyagi/functionz/packs/plugins/augie.py
+++ /dev/null
@@ -1,123 +0,0 @@
-from babyagi.functionz.core.framework import func
-
-@func.register_function(
- metadata={"description": "Generate parameters for Augie creation using GPT."},
- dependencies=["gpt_call"]
-)
-def generate_augie_params(user_input, voice_id="29vD33N1CtxCmqQRPOHJ"):
- """
- This function generates JSON parameters for creating an Augie video.
- It uses GPT to structure the user input into the required format, keeping the default voice_id.
-
- Parameters:
- - user_input: The basic user input text.
- - voice_id: Default voice ID (not generated by GPT).
-
- Returns: A dictionary with the necessary parameters for creating the Augie video.
- """
- prompt = (
- "You are creating parameters for a video generation API request. "
- "The user has provided input text for the video content. Structure the input into the following JSON format:\n"
- "{\n"
- " 'name': '',\n"
- " 'text': '',\n"
- " 'orientation': 'landscape' or 'portrait',\n"
- " 'make_video': true or false\n"
- "}\n"
- "Do not generate a voice ID, use the one provided by the API system."
- )
-
- gpt_output = gpt_call({"prompt": prompt, "user_input": user_input})
-
- # Parse GPT output and construct parameters
- params = gpt_output['text'] # Assuming gpt_call returns a structured response.
- params['voice_id'] = voice_id # Set the default voice ID.
-
- return params
-
-
-@func.register_function(
- metadata={"description": "Creates a video on Augie platform."},
- key_dependencies=["augie_api_key"],
- imports={"name": "requests", "lib": "requests"}
-)
-def create_augie(params):
- """Function to create a video on Augie platform with parameters."""
- API_KEY = globals()['augie_api_key']
- BASE_URL = 'https://beta.api.augie.studio/v1'
-
- headers = {
- 'x-api-key': API_KEY,
- 'Content-Type': 'application/json'
- }
-
- import requests
- response = requests.post(f'{BASE_URL}/augies', json=params, headers=headers)
-
- if response.status_code == 201:
- return response.json() # Returns the creation response
- else:
- raise Exception(f"Failed to create Augie: {response.text}")
-
-
-@func.register_function(
- metadata={"description": "Checks the status of the created video."},
- key_dependencies=["augie_api_key"],
- imports={"name": "requests", "lib": "requests"}
-)
-def get_augie_status(augie_id):
- """Function to check the status of an Augie video creation."""
- API_KEY = globals()['augie_api_key']
- BASE_URL = 'https://beta.api.augie.studio/v1'
-
- headers = {
- 'x-api-key': API_KEY
- }
-
- import requests
- response = requests.get(f'{BASE_URL}/augies/{augie_id}/status', headers=headers)
-
- if response.status_code == 200:
- status_data = response.json()
- if status_data.get('status') == 'succeeded' and 'output' in status_data and 'video' in status_data['output']:
- return {"status": "completed", "video_url": status_data['output']['video']}
- else:
- return {"status": "processing"}
- else:
- raise Exception(f"Failed to get Augie status: {response.text}")
-
-
-@func.register_function(
- metadata={"description": "Wrapper to create a video and keep checking its status until available."},
- dependencies=["generate_augie_params", "create_augie", "get_augie_status"],
- imports={"name": "time", "lib": "time"}
-)
-def create_and_wait_for_video(user_input, timeout=300, interval=10):
- """
- Wrapper function to create a video from user input and wait for it to be available.
- - user_input: Basic input from the user, processed by GPT.
- - timeout: The max time to wait (in seconds).
- - interval: Time between status checks (in seconds).
- """
- import time
-
- # Generate parameters using GPT
- params = generate_augie_params(user_input)
-
- # Create the video
- creation_response = create_augie(params)
- augie_id = creation_response.get('id')
-
- if not augie_id:
- raise Exception("Failed to retrieve Augie ID after creation.")
-
- # Wait and check the status periodically
- start_time = time.time()
- while time.time() - start_time < timeout:
- status_response = get_augie_status(augie_id)
- if status_response['status'] == 'completed':
- return status_response # Return video URL if available
- time.sleep(interval)
-
- # Timeout reached, return failure
- raise TimeoutError(f"Video creation timed out after {timeout} seconds.")
diff --git a/babyagi/functionz/packs/plugins/e2b.py b/babyagi/functionz/packs/plugins/e2b.py
deleted file mode 100644
index 43e86547..00000000
--- a/babyagi/functionz/packs/plugins/e2b.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import babyagi
-
-@babyagi.register_function(
- metadata={"description": "Executes AI-generated Python code in a secure E2B sandbox."},
- imports=["e2b_code_interpreter"],
- key_dependencies=["e2b_api_key"]
-)
-def execute_code_in_sandbox(code: str):
- """
- This function initializes an E2B sandbox and executes AI-generated Python code within it.
-
- :param code: Python code to be executed.
- :return: Results and logs from the code execution.
- """
- from e2b_code_interpreter import CodeInterpreter
-
- with CodeInterpreter() as sandbox:
- # Execute the code in the sandbox
- execution = sandbox.notebook.exec_cell(code)
-
- # Handle execution errors
- if execution.error:
- return {"error": execution.error.name, "message": execution.error.value, "traceback": execution.error.traceback}
-
- # Gather results
- results = [{"text": result.text, "formats": result.formats()} for result in execution.results]
- logs = {"stdout": execution.logs.stdout, "stderr": execution.logs.stderr}
-
- return {"results": results, "logs": logs}
-
-
-# Function 2: Chat with LLM (OpenAI) and parse response to execute in sandbox
-
-@babyagi.register_function(
- metadata={"description": "Calls the OpenAI API (gpt-3.5-turbo) to generate code and execute it in an E2B sandbox."},
- imports=["litellm", "os"],
- key_dependencies=["openai_api_key"],
- dependencies=["execute_code_in_sandbox"]
-)
-def chat_with_llm_and_execute(user_message: str):
- """
- This function calls the OpenAI API (via litellm) to generate Python code based on the user's message,
- then executes that code in an E2B sandbox.
-
- :param user_message: The message to prompt the LLM with.
- :return: Results from the executed code and logs.
- """
- from litellm import completion
-
- # Load OpenAI API key from environment
- api_key = globals()['openai_api_key']
-
- # Define the message for the LLM
- messages = [{"role": "user", "content": user_message}]
-
- # Call the LLM using litellm completion method
- response = completion(model="gpt-3.5-turbo", messages=messages)
- llm_generated_code = response['choices'][0]['message']['content']
-
- # Execute the generated code in the E2B sandbox
- return execute_code_in_sandbox(llm_generated_code)
-
-
-# Function 3: Save generated charts
-
-@babyagi.register_function(
- metadata={"description": "Saves a base64-encoded PNG chart to a file."},
- imports=["base64"],
-)
-def save_chart(base64_png: str, filename: str = "chart.png"):
- """
- Saves a base64-encoded PNG chart to a file.
-
- :param base64_png: Base64-encoded PNG data.
- :param filename: The name of the file to save the chart.
- :return: The path to the saved chart.
- """
- png_data = base64.b64decode(base64_png)
-
- # Save the decoded PNG to a file
- with open(filename, "wb") as file:
- file.write(png_data)
-
- return f"Chart saved to {filename}"
-
-
-# Function 4: Execute main flow (chat with LLM, run code, save chart if exists)
-
-@babyagi.register_function(
- metadata={"description": "Main function to prompt LLM, execute code in E2B, and save any generated charts."},
- dependencies=["chat_with_llm_and_execute", "save_chart"]
-)
-def e2b_llm_to_chart(user_message: str):
- """
- The main workflow function: sends a message to the LLM, executes the generated code, and saves any charts.
-
- :param user_message: The user's input prompt for the LLM.
- :return: Final results and path to saved chart if applicable.
- """
- # Get code execution results and logs
- execution_results = chat_with_llm_and_execute(user_message)
-
- # Check if any chart (PNG) was generated
- if execution_results["results"]:
- for result in execution_results["results"]:
- if "png" in result["formats"]:
- # Save the chart if PNG format is present
- chart_filename = save_chart(result["formats"]["png"])
- return {"execution_results": execution_results, "chart_saved_to": chart_filename}
-
- return {"execution_results": execution_results}
diff --git a/babyagi/functionz/packs/plugins/firecrawl.py b/babyagi/functionz/packs/plugins/firecrawl.py
deleted file mode 100644
index ee171445..00000000
--- a/babyagi/functionz/packs/plugins/firecrawl.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# 1. Crawl a website and initiate a crawl job.
-@func.register_function(
- metadata={"description": "Submits a crawl job for a website and returns a job ID."},
- key_dependencies=["firecrawl_api_key"],
- imports={"name":"firecrawl","lib":"firecrawl-py"}
-)
-def crawl_website(url: str, limit: int = 100, formats: list = ["markdown", "html"], poll_interval: int = 30):
- """
- Submits a crawl job for the given URL and returns the crawl job status and job ID.
- """
- from firecrawl import FirecrawlApp
- api_key = globals()['firecrawl_api_key']
- app = FirecrawlApp(api_key=api_key)
-
- try:
- crawl_status = app.crawl_url(
- url,
- params={'limit': limit, 'scrapeOptions': {'formats': formats}},
- poll_interval=poll_interval
- )
- return crawl_status
- except Exception as e:
- return {"error": str(e)}
-
-
-# 2. Check the status of a crawl job.
-@func.register_function(
- metadata={"description": "Checks the status of an ongoing or completed crawl job by its job ID."},
- key_dependencies=["firecrawl_api_key"],
- imports={"name":"firecrawl","lib":"firecrawl-py"}
-)
-def check_crawl_status(crawl_id: str):
- """
- Checks the status of the crawl job and returns the job details including markdown and HTML data.
- """
- from firecrawl import FirecrawlApp
- api_key = globals()['firecrawl_api_key']
- app = FirecrawlApp(api_key=api_key)
-
- try:
- crawl_status = app.check_crawl_status(crawl_id)
- return crawl_status
- except Exception as e:
- return {"error": str(e)}
-
-
-# 3. Scrape a single website URL for markdown and HTML data.
-@func.register_function(
- metadata={"description": "Scrapes a single URL and returns markdown and HTML content."},
- key_dependencies=["firecrawl_api_key"],
- imports={"name":"firecrawl","lib":"firecrawl-py"}
-)
-def scrape_website(url: str, formats: list = ["markdown", "html"]):
- """
- Scrapes the given URL and returns the data (markdown, HTML, and metadata).
- """
- from firecrawl import FirecrawlApp
- api_key = globals()['firecrawl_api_key']
- app = FirecrawlApp(api_key=api_key)
-
- try:
- scrape_result = app.scrape_url(url, params={'formats': formats})
- return scrape_result
- except Exception as e:
- return {"error": str(e)}
diff --git a/babyagi/functionz/packs/plugins/payman.py b/babyagi/functionz/packs/plugins/payman.py
deleted file mode 100644
index 162eaadd..00000000
--- a/babyagi/functionz/packs/plugins/payman.py
+++ /dev/null
@@ -1,188 +0,0 @@
-from babyagi.functionz.core.framework import func
-
-# Store API keys (both test and real) from Replit secrets into the function database
-@func.register_function(
- metadata={"description": "Store PayMan API keys (test and real) from Replit secrets into the function database"},
- imports=["os"]
-)
-def store_payman_api_keys():
- # Store test API key
- func.add_key('payman_test_api_key', os.environ['PAYMAN_TEST_API_KEY'])
- # Store real API key
- func.add_key('payman_api_key', os.environ['PAYMAN_API_KEY'])
-
-
-# Create Task Function
-@func.register_function(
- metadata={"description": "Create a task on PayMan platform (test by default, real if 'real_money' is True)"},
- key_dependencies=["payman_test_api_key", "payman_api_key"],
- imports=["requests"]
-)
-def create_task(title: str, description: str, payout: int, currency: str = "USD", category: str = "MARKETING", real_money: bool = False):
- if real_money:
- api_key = globals()['payman_api_key']
- base_url = "https://agent.payman.ai/api"
- else:
- api_key = globals()['payman_test_api_key']
- base_url = "https://agent-sandbox.payman.ai/api"
-
- headers = {
- "x-payman-api-secret": api_key,
- "Content-Type": "application/json",
- "Accept": "application/vnd.payman.v1+json"
- }
- payload = {
- "title": title,
- "description": description,
- "payout": payout, # Payout in cents (e.g. 5000 for $50)
- "currency": currency,
- "category": category,
- "requiredSubmissions": 1,
- "submissionPolicy": "OPEN_SUBMISSIONS_ONE_PER_USER"
- }
- try:
- response = requests.post(f"{base_url}/tasks", headers=headers, json=payload)
- return response.json()
- except requests.exceptions.HTTPError as e:
- return {"error": str(e)}
-
-
-# Get Task by ID Function
-@func.register_function(
- metadata={"description": "Get a task by its ID on PayMan platform (test by default, real if 'real_money' is True)"},
- key_dependencies=["payman_test_api_key", "payman_api_key"],
- imports=["requests"]
-)
-def get_task_by_id(task_id: str, real_money: bool = False):
- if real_money:
- api_key = globals()['payman_api_key']
- base_url = "https://agent.payman.ai/api"
- else:
- api_key = globals()['payman_test_api_key']
- base_url = "https://agent-sandbox.payman.ai/api"
-
- headers = {
- "x-payman-api-secret": api_key,
- "Content-Type": "application/json",
- "Accept": "application/vnd.payman.v1+json"
- }
- try:
- response = requests.get(f"{base_url}/tasks/{task_id}", headers=headers)
- return response.json()
- except requests.exceptions.HTTPError as e:
- return {"error": str(e)}
-
-
-# Get All Tasks Function
-@func.register_function(
- metadata={"description": "Get all tasks for the current organization on PayMan platform (test by default, real if 'real_money' is True)"},
- key_dependencies=["payman_test_api_key", "payman_api_key"],
- imports=["requests"]
-)
-def get_all_tasks(page: int = 0, limit: int = 20, real_money: bool = False):
- if real_money:
- api_key = globals()['payman_api_key']
- base_url = "https://agent.payman.ai/api"
- else:
- api_key = globals()['payman_test_api_key']
- base_url = "https://agent-sandbox.payman.ai/api"
-
- headers = {
- "x-payman-api-secret": api_key,
- "Content-Type": "application/json",
- "Accept": "application/vnd.payman.v1+json"
- }
- params = {
- "page": page,
- "limit": limit
- }
- try:
- response = requests.get(f"{base_url}/tasks", headers=headers, params=params)
- return response.json()
- except requests.exceptions.HTTPError as e:
- return {"error": str(e)}
-
-
-@func.register_function(
- metadata={"description": "Get all submissions for a task on PayMan platform (test by default, real if 'real_money' is True)"},
- key_dependencies=["payman_test_api_key", "payman_api_key"],
- imports=["requests"]
-)
-def get_task_submissions(task_id: str, statuses: list = None, page: int = 0, limit: int = 20, real_money: bool = False):
- if real_money:
- api_key = globals()['payman_api_key']
- base_url = "https://agent.payman.ai/api"
- else:
- api_key = globals()['payman_test_api_key']
- base_url = "https://agent-sandbox.payman.ai/api"
-
- headers = {
- "x-payman-api-secret": api_key,
- "Content-Type": "application/json",
- "Accept": "application/vnd.payman.v1+json"
- }
-
- params = {
- "page": page,
- "limit": limit
- }
-
- if statuses:
- params["statuses"] = ",".join(statuses)
-
- try:
- response = requests.get(f"{base_url}/tasks/{task_id}/submissions", headers=headers, params=params)
- return response.json()
- except requests.exceptions.HTTPError as e:
- return {"error": str(e)}
-
-# Approve Task Submission Function
-@func.register_function(
- metadata={"description": "Approve a task submission on PayMan platform (test by default, real if 'real_money' is True)"},
- key_dependencies=["payman_test_api_key", "payman_api_key"],
- imports=["requests"]
-)
-def approve_task_submission(submission_id: str, real_money: bool = False):
- if real_money:
- api_key = globals()['payman_api_key']
- base_url = "https://agent.payman.ai/api"
- else:
- api_key = globals()['payman_test_api_key']
- base_url = "https://agent-sandbox.payman.ai/api"
-
- headers = {
- "x-payman-api-secret": api_key,
- "Content-Type": "application/json",
- "Accept": "application/vnd.payman.v1+json"
- }
- try:
- response = requests.post(f"{base_url}/tasks/submissions/{submission_id}/approve", headers=headers)
- return response.json()
- except requests.exceptions.HTTPError as e:
- return {"error": str(e)}
-
-
-# Reject Task Submission Function
-@func.register_function(
- metadata={"description": "Reject a task submission on PayMan platform (test by default, real if 'real_money' is True)"},
- key_dependencies=["payman_test_api_key", "payman_api_key"],
- imports=["requests"]
-)
-def reject_task_submission(submission_id: str, rejection_reason: str, real_money: bool = False):
- if real_money:
- api_key = globals()['payman_api_key']
- base_url = "https://agent.payman.ai/api"
- else:
- api_key = globals()['payman_test_api_key']
- base_url = "https://agent-sandbox.payman.ai/api"
-
- headers = {
- "x-payman-api-secret": api_key,
- "Content-Type": "application/json",
- "Accept": "application/vnd.payman.v1+json"
- }
- try:
- response = requests.post(f"{base_url}/tasks/submissions/{submission_id}/reject", headers=headers, json=rejection_reason)
- return response.json()
- except requests.exceptions.HTTPError as e:
- return {"error": str(e)}
diff --git a/babyagi/functionz/packs/plugins/serpapi.py b/babyagi/functionz/packs/plugins/serpapi.py
deleted file mode 100644
index 9ee0ac30..00000000
--- a/babyagi/functionz/packs/plugins/serpapi.py
+++ /dev/null
@@ -1,65 +0,0 @@
-@func.register_function(
- metadata={
- "description": "Perform a search using the latest SerpApi Python client library with customizable parameters."
- },
- key_dependencies=["serpapi_api_key"],
- imports=["serpapi"]
-)
-def serpapi_search_v2(query: str, engine: str = "google", location: str = "United States", language: str = "en", country: str = "us", safe_search: bool = False, num_results: int = 10, start: int = 0, async_request: bool = False, output_format: str = "json"):
- """
- Perform a search using the SerpApi service with a flexible set of parameters.
-
- Args:
- query (str): The search query.
- engine (str): The search engine to use (e.g., 'google', 'bing'). Default is 'google'.
- location (str): The location to target the search. Default is 'United States'.
- language (str): UI language for the search. Default is 'en'.
- country (str): Country code for the search. Default is 'us'.
- safe_search (bool): Flag for SafeSearch filtering. Default is False.
- num_results (int): Number of search results to retrieve. Default is 10.
- start (int): Pagination offset. Default is 0.
- async_request (bool): Whether to make an asynchronous request. Default is False.
- output_format (str): Format of the output ('json' or 'html'). Default is 'json'.
-
- Returns:
- dict or str: The search results in the specified format.
- """
- # Import necessary modules and classes within function scope.
-
- # Get the API key from the global variables.
- api_key = globals().get("serpapi_api_key", "")
- if not api_key:
- raise ValueError("API key is missing. Please provide a valid SerpApi key.")
-
- # Initialize the SerpApi client.
- client = serpapi.Client(api_key=api_key)
-
- # Define the search parameters.
- params = {
- "q": query,
- "engine": engine,
- "location": location,
- "hl": language,
- "gl": country,
- "safe": "active" if safe_search else "off",
- "num": num_results,
- "start": start,
- "async": async_request,
- "output": output_format,
- }
-
- try:
- # Perform the search and get the results.
- search_results = client.search(**params)
-
- # Return the results in the specified format.
- if output_format == "json":
- return search_results.as_dict()
- elif output_format == "html":
- return search_results.get("raw_html", "No HTML content found.")
- else:
- raise ValueError("Invalid output format specified. Choose either 'json' or 'html'.")
-
- except requests.exceptions.HTTPError as e:
- # Handle potential SerpApi errors and HTTP errors.
- return {"error": str(e)}
diff --git a/babyagi/functionz/packs/plugins/voilanorbert.py b/babyagi/functionz/packs/plugins/voilanorbert.py
deleted file mode 100644
index 4e9b3dc1..00000000
--- a/babyagi/functionz/packs/plugins/voilanorbert.py
+++ /dev/null
@@ -1,92 +0,0 @@
-@func.register_function(
- metadata={"description": "Search for a contact by name and domain using VoilaNorbert's API."},
- key_dependencies=["voilanorbert_api_key"],
- imports=["requests", "time"]
-)
-def search_contact_by_name_domain(name, domain):
- """
- Searches for a contact by name and domain using the VoilaNorbert API.
-
- Args:
- name (str): Full name of the person to search.
- domain (str): Domain of the company the person works for.
-
- Returns:
- dict: The contact information if found, otherwise an appropriate message.
- """
- api_key = globals().get('voilanorbert_api_key')
- if not api_key:
- return {"error": "API key not found"}
-
- # Prepare the API request
- search_url = 'https://api.voilanorbert.com/2018-01-08/search/name'
- auth = ('any_string', api_key)
- data = {'name': name, 'domain': domain}
-
- try:
- # POST request to initiate search
- response = requests.post(search_url, auth=auth, data=data)
- if response.status_code == 402:
- return {"error": "No credits available for this search"}
- elif response.status_code != 200:
- return {"error": f"Failed to search contact: {response.json()}"}
-
- result = response.json()
- contact_id = result.get('id')
-
- # Polling to check if the email is found
- contact_url = f'https://api.voilanorbert.com/2018-01-08/contacts/{contact_id}'
- while True:
- contact_response = requests.get(contact_url, auth=auth)
- if contact_response.status_code == 200:
- contact_data = contact_response.json()
- if not contact_data['searching']:
- if contact_data['email']:
- return {
- "email": contact_data['email']['email'],
- "score": contact_data['email']['score']
- }
- return {"message": "Email not found!"}
- time.sleep(10)
-
- except requests.RequestException as e:
- return {"error": str(e)}
-
-
-@func.register_function(
- metadata={"description": "Search for contacts by domain using VoilaNorbert's API."},
- key_dependencies=["voilanorbert_api_key"],
- imports=["requests"]
-)
-def search_contact_by_domain(domain):
- """
- Searches for contacts by domain using the VoilaNorbert API.
-
- Args:
- domain (str): The domain of the company to search for contacts.
-
- Returns:
- list: A list of found contacts with emails if available.
- """
- api_key = globals().get('voilanorbert_api_key')
- if not api_key:
- return {"error": "API key not found"}
-
- # Prepare the API request
- search_url = 'https://api.voilanorbert.com/2018-01-08/search/domain'
- auth = ('any_string', api_key)
- data = {'domain': domain}
-
- try:
- # POST request to initiate search
- response = requests.post(search_url, auth=auth, data=data)
- if response.status_code == 402:
- return {"error": "No credits available for this search"}
- elif response.status_code != 200:
- return {"error": f"Failed to search contacts: {response.json()}"}
-
- result = response.json()
- return result.get('result', [])
-
- except requests.RequestException as e:
- return {"error": str(e)}
diff --git a/babyagi/functionz/packs/plugins/wokelo.py b/babyagi/functionz/packs/plugins/wokelo.py
deleted file mode 100644
index 8f81c2a5..00000000
--- a/babyagi/functionz/packs/plugins/wokelo.py
+++ /dev/null
@@ -1,139 +0,0 @@
-@func.register_function(
- metadata={"description": "Get an authentication token using the Wokelo API credentials."},
- key_dependencies=["wokelo_username", "wokelo_password"],
- imports=[{"name": "requests", "lib": "requests"}]
-)
-def get_auth_token():
- """Obtain an authentication token using Wokelo API credentials stored as secrets."""
- import requests
- BASE_URL = 'https://api.wokelo.ai'
- url = BASE_URL + '/auth/token'
-
- headers = {"Content-Type": "application/x-www-form-urlencoded"}
- data = {
- "client_id": "B5I07FeItrqH5V8ytQKNwHPDHeMQnGBheg7A6FAg",
- "client_secret": "JkVEP6FZhTkolz9vwkFSFAMVKLO0r9CnYU2RlGcRSzxZGZSkdSbSCed30VHg55IWU94F3sh0fTGUy8dTGslQZmcpCGvPhEUs9w3uobWa4ftXvsahriFCReRIxEUdd2f8",
- "grant_type": "password",
- "username": globals()['wokelo_username'],
- "password": globals()['wokelo_password'],
- }
-
- response = requests.post(url, headers=headers, data=data)
-
- if response.status_code == 200:
- # Successfully obtained token
- token_info = response.json()
- return token_info.get("access_token")
- else:
- return {"error": f"Failed to obtain token. Status code: {response.status_code}", "details": response.text}
-
-
-@func.register_function(
- metadata={"description": "Create an industry snapshot report in Wokelo."},
- dependencies=["get_auth_token"],
- imports=[{"name": "requests", "lib": "requests"}]
-)
-def create_industry_snapshot(access_token: str, industry_name: str):
- """Initiate a new industry snapshot report."""
- import requests
- BASE_URL = 'https://api.wokelo.ai'
- url = f'{BASE_URL}/api/industry_primer/v3/start/'
- headers = {'Authorization': f'Bearer {access_token}', 'Content-Type': 'application/json'}
- payload = {"industry": industry_name}
-
- response = requests.post(url, json=payload, headers=headers)
- if response.status_code == 200:
- return response.json().get('report_id')
- else:
- return {"error": "Failed to create industry snapshot.", "details": response.text}
-
-
-@func.register_function(
- metadata={"description": "Check the status of an industry report using its report ID."},
- dependencies=["get_auth_token"],
- imports=[{"name": "requests", "lib": "requests"}]
-)
-def check_report_status(access_token: str, report_id: str):
- """Check the status of a generated report in Wokelo."""
- import requests
- BASE_URL = 'https://api.wokelo.ai'
- url = f'{BASE_URL}/api/assets/get_report_status/?report_id={report_id}'
- headers = {'Authorization': f'Bearer {access_token}'}
-
- response = requests.get(url, headers=headers)
- if response.status_code == 200:
- return response.json()
- else:
- return {"error": "Failed to check report status.", "details": response.text}
-
-
-@func.register_function(
- metadata={"description": "Download the generated report from Wokelo."},
- dependencies=["get_auth_token"],
- imports=[{"name": "requests", "lib": "requests"}]
-)
-def download_report(access_token: str, report_id: str, file_type: str = 'pdf'):
- """Download a specific report in a given file format."""
- import requests
- BASE_URL = 'https://api.wokelo.ai'
- url = f'{BASE_URL}/api/assets/download_report/'
- headers = {'Authorization': f'Bearer {access_token}', 'Content-Type': 'application/json'}
- payload = {"file_type": file_type, "report_id": report_id}
-
- response = requests.post(url, json=payload, headers=headers)
- if response.status_code == 200:
- return response.content
- else:
- return {"error": "Failed to download report.", "details": response.text}
-
-
-@func.register_function(
- metadata={"description": "Generate an industry report in Wokelo by tying all steps together."},
- dependencies=["get_auth_token", "create_industry_snapshot", "check_report_status", "download_report"],
- imports=[{"name": "time", "lib": "time"}]
-)
-def generate_industry_report(industry_name: str, file_type: str = 'pdf'):
- """
- Complete workflow for generating and downloading an industry report.
-
- Args:
- industry_name (str): The name of the industry to generate the report for.
- file_type (str): The format of the report file to be downloaded. Default is 'pdf'.
-
- Returns:
- str: File path of the downloaded report.
- """
- # Step 1: Get an authentication token.
- access_token = get_auth_token()
- if not isinstance(access_token, str):
- return access_token # If there's an error, return the error message.
-
- # Step 2: Create an industry snapshot.
- report_id = create_industry_snapshot(access_token, industry_name)
- if not isinstance(report_id, str):
- return report_id # If there's an error, return the error message.
-
- # Step 3: Check report status until it's ready.
- print(f"Initiated report creation. Waiting for the report (ID: {report_id}) to be exported.")
- while True:
- status_info = check_report_status(access_token, report_id)
- if 'status' in status_info and status_info['status'] == 'exported':
- print(f"Report is ready for download: {report_id}")
- break
- elif 'status' in status_info:
- print(f"Current report status: {status_info['status']}. Checking again in 30 seconds...")
- else:
- return status_info # Error occurred.
- time.sleep(30)
-
- # Step 4: Download the report.
- report_content = download_report(access_token, report_id, file_type)
- if isinstance(report_content, dict) and 'error' in report_content:
- return report_content # Return the error if download failed.
-
- # Step 5: Save the report locally.
- report_filename = f'report_{report_id}.{file_type}'
- with open(report_filename, 'wb') as report_file:
- report_file.write(report_content)
-
- return f"Report downloaded successfully: {report_filename}"
diff --git a/babycoder/README.md b/babycoder/README.md
new file mode 100644
index 00000000..53b5fed0
--- /dev/null
+++ b/babycoder/README.md
@@ -0,0 +1,40 @@
+# Babycoder: Recipe for using BabyAgi to write code
+
+Babycoder is a work in progress AI system that is able to write code for small programs given a simple objective. As a part of the BabyAgi system, Babycoder's goal is to lay the foundation for creating increasingly powerful AI agents capable of managing larger and more complex projects.
+
+## Objective
+
+The primary objective of Babycoder is to provide a recipe for developing AI agent systems capable of writing and editing code. By starting with a simple system and iterating on it, Babycoder aims to improve over time and eventually handle more extensive projects.
+
+## How It Works
+
+
+
+
+
+Babycoder's task management system consists of several AI agents working together to create, prioritize, and execute tasks based on a predefined objective and the current state of the project being worked on. The process consists of the following steps:
+
+1. **Task Definition**: Four task agents define tasks in a JSON list, which includes all tasks to be executed by the system.
+
+2. **(Optional) Human feedback**: If enabled, allows to provide feedback for each task before it is executed. The feedback is processed by an agent responsible for applying it to improve the task.
+
+3. **Agent Assignment**: For each task, two agents collaborate to determine the agent responsible for executing the task. The possible executor agents are:
+ - `command_executor_agent`
+ - `code_writer_agent`
+ - `code_refactor_agent`
+
+4. **File Management**: The `files_management_agent` scans files in the project directory to determine which files or folders will be used by the executor agents to accomplish their tasks.
+
+5. **Task Execution**: The executor agents perform their assigned tasks using the following capabilities:
+ - The `command_executor_agent` runs OS commands, such as installing dependencies or creating files and folders.
+ - The `code_writer_agent` writes new code or updates existing code, using embeddings of the current codebase to retrieve relevant code sections and ensure compatibility with other parts of the codebase.
+ - The `code_refactor_agent` edits existing code according to the specified task, with the help of a `code_relevance_agent` that analyzes code chunks and identifies the most relevant section for editing.
+
+The code is written to a folder called `playground` in Babycoder's root directory. A folder named `playground_data` is used to save embeddings of the code being written.
+
+## How to use
+
+- Configure BabyAgi by following the instructions in the main README file.
+- Navigate to the babycoder directory: `cd babycoder`
+- Make a copy of the objective.sample.txt file (`cp objective.sample.txt objective.txt`) and update it to contain the objective of the project you want to create.
+- Finally, from the `./babycoder` directory, run: `python babycoder.py` and watch it write code for you!
diff --git a/babycoder/babycoder.py b/babycoder/babycoder.py
new file mode 100644
index 00000000..321b3b6f
--- /dev/null
+++ b/babycoder/babycoder.py
@@ -0,0 +1,610 @@
+import os
+import openai
+import time
+import sys
+from typing import List, Dict, Union
+from dotenv import load_dotenv
+import json
+import subprocess
+import platform
+
+from embeddings import Embeddings
+
+# Set Variables
+load_dotenv()
+current_directory = os.getcwd()
+os_version = platform.release()
+
+openai_calls_retried = 0
+max_openai_calls_retries = 3
+
+# Set API Keys
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+assert OPENAI_API_KEY, "OPENAI_API_KEY environment variable is missing from .env"
+openai.api_key = OPENAI_API_KEY
+
+OPENAI_API_MODEL = os.getenv("OPENAI_API_MODEL", "gpt-3.5-turbo")
+assert OPENAI_API_MODEL, "OPENAI_API_MODEL environment variable is missing from .env"
+
+if "gpt-4" in OPENAI_API_MODEL.lower():
+ print(
+ f"\033[91m\033[1m"
+ + "\n*****USING GPT-4. POTENTIALLY EXPENSIVE. MONITOR YOUR COSTS*****"
+ + "\033[0m\033[0m"
+ )
+
+if len(sys.argv) > 1:
+ OBJECTIVE = sys.argv[1]
+elif os.path.exists(os.path.join(current_directory, "objective.txt")):
+ with open(os.path.join(current_directory, "objective.txt")) as f:
+ OBJECTIVE = f.read()
+
+assert OBJECTIVE, "OBJECTIVE missing"
+
+## Start of Helper/Utility functions ##
+
+def print_colored_text(text, color):
+ color_mapping = {
+ 'blue': '\033[34m',
+ 'red': '\033[31m',
+ 'yellow': '\033[33m',
+ 'green': '\033[32m',
+ }
+ color_code = color_mapping.get(color.lower(), '')
+ reset_code = '\033[0m'
+ print(color_code + text + reset_code)
+
+def print_char_by_char(text, delay=0.00001, chars_at_once=3):
+ for i in range(0, len(text), chars_at_once):
+ chunk = text[i:i + chars_at_once]
+ print(chunk, end='', flush=True)
+ time.sleep(delay)
+ print()
+
+def openai_call(
+ prompt: str,
+ model: str = OPENAI_API_MODEL,
+ temperature: float = 0.5,
+ max_tokens: int = 100,
+):
+ global openai_calls_retried
+ if not model.startswith("gpt-"):
+ # Use completion API
+ response = openai.Completion.create(
+ engine=model,
+ prompt=prompt,
+ temperature=temperature,
+ max_tokens=max_tokens,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+ return response.choices[0].text.strip()
+ else:
+ # Use chat completion API
+ messages=[{"role": "user", "content": prompt}]
+ try:
+ response = openai.ChatCompletion.create(
+ model=model,
+ messages=messages,
+ temperature=temperature,
+ max_tokens=max_tokens,
+ n=1,
+ stop=None,
+ )
+ openai_calls_retried = 0
+ return response.choices[0].message.content.strip()
+ except Exception as e:
+ # try again
+ if openai_calls_retried < max_openai_calls_retries:
+ openai_calls_retried += 1
+ print(f"Error calling OpenAI. Retrying {openai_calls_retried} of {max_openai_calls_retries}...")
+ return openai_call(prompt, model, temperature, max_tokens)
+
+def execute_command_json(json_string):
+ try:
+ command_data = json.loads(json_string)
+ full_command = command_data.get('command')
+
+ process = subprocess.Popen(full_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True, cwd='playground')
+ stdout, stderr = process.communicate(timeout=60)
+
+ return_code = process.returncode
+
+ if return_code == 0:
+ return stdout
+ else:
+ return stderr
+
+ except json.JSONDecodeError as e:
+ return f"Error: Unable to decode JSON string: {str(e)}"
+ except subprocess.TimeoutExpired:
+ process.terminate()
+ return "Error: Timeout reached (60 seconds)"
+ except Exception as e:
+ return f"Error: {str(e)}"
+
+def execute_command_string(command_string):
+ try:
+ result = subprocess.run(command_string, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True, cwd='playground')
+ output = result.stdout or result.stderr or "No output"
+ return output
+
+ except Exception as e:
+ return f"Error: {str(e)}"
+
+def save_code_to_file(code: str, file_path: str):
+ full_path = os.path.join(current_directory, "playground", file_path)
+ try:
+ mode = 'a' if os.path.exists(full_path) else 'w'
+ with open(full_path, mode, encoding='utf-8') as f:
+ f.write(code + '\n\n')
+ except:
+ pass
+
+def refactor_code(modified_code: List[Dict[str, Union[int, str]]], file_path: str):
+ full_path = os.path.join(current_directory, "playground", file_path)
+
+ with open(full_path, "r", encoding="utf-8") as f:
+ lines = f.readlines()
+
+ for modification in modified_code:
+ start_line = modification["start_line"]
+ end_line = modification["end_line"]
+ modified_chunk = modification["modified_code"].splitlines()
+
+ # Remove original lines within the range
+ del lines[start_line - 1:end_line]
+
+ # Insert the new modified_chunk lines
+ for i, line in enumerate(modified_chunk):
+ lines.insert(start_line - 1 + i, line + "\n")
+
+ with open(full_path, "w", encoding="utf-8") as f:
+ f.writelines(lines)
+
+def split_code_into_chunks(file_path: str, chunk_size: int = 50) -> List[Dict[str, Union[int, str]]]:
+ full_path = os.path.join(current_directory, "playground", file_path)
+
+ with open(full_path, "r", encoding="utf-8") as f:
+ lines = f.readlines()
+
+ chunks = []
+ for i in range(0, len(lines), chunk_size):
+ start_line = i + 1
+ end_line = min(i + chunk_size, len(lines))
+ chunk = {"start_line": start_line, "end_line": end_line, "code": "".join(lines[i:end_line])}
+ chunks.append(chunk)
+ return chunks
+
+## End of Helper/Utility functions ##
+
+## TASKS AGENTS ##
+
+def code_tasks_initializer_agent(objective: str):
+ prompt = f"""You are an AGI agent responsible for creating a detailed JSON checklist of tasks that will guide other AGI agents to complete a given programming objective. Your task is to analyze the provided objective and generate a well-structured checklist with a clear starting point and end point, as well as tasks broken down to be very specific, clear, and executable by other agents without the context of other tasks.
+
+ The current agents work as follows:
+ - code_writer_agent: Writes code snippets or functions and saves them to the appropriate files. This agent can also append code to existing files if required.
+ - code_refactor_agent: Responsible for modifying and refactoring existing code to meet the requirements of the task.
+ - command_executor_agent: Executes terminal commands for tasks such as creating directories, installing dependencies, etc.
+
+ Keep in mind that the agents cannot open files in text editors, and tasks should be designed to work within these agent capabilities.
+
+ Here is the programming objective you need to create a checklist for: {objective}.
+
+ To generate the checklist, follow these steps:
+
+ 1. Analyze the objective to identify the high-level requirements and goals of the project. This will help you understand the scope and create a comprehensive checklist.
+
+ 2. Break down the objective into smaller, highly specific tasks that can be worked on independently by other agents. Ensure that the tasks are designed to be executed by the available agents (code_writer_agent, code_refactor and command_executor_agent) without requiring opening files in text editors.
+
+ 3. Assign a unique ID to each task for easy tracking and organization. This will help the agents to identify and refer to specific tasks in the checklist.
+
+ 4. Organize the tasks in a logical order, with a clear starting point and end point. The starting point should represent the initial setup or groundwork necessary for the project, while the end point should signify the completion of the objective and any finalization steps.
+
+ 5. Provide the current context for each task, which should be sufficient for the agents to understand and execute the task without referring to other tasks in the checklist. This will help agents avoid task duplication.
+
+ 6. Pay close attention to the objective and make sure the tasks implement all necessary pieces needed to make the program work.
+
+ 7. Compile the tasks into a well-structured JSON format, ensuring that it is easy to read and parse by other AGI agents. The JSON should include fields such as task ID, description and file_path.
+
+ IMPORTANT: BE VERY CAREFUL WITH IMPORTS AND MANAGING MULTIPLE FILES. REMEMBER EACH AGENT WILL ONLY SEE A SINGLE TASK. ASK YOURSELF WHAT INFORMATION YOU NEED TO INCLUDE IN THE CONTEXT OF EACH TASK TO MAKE SURE THE AGENT CAN EXECUTE THE TASK WITHOUT SEEING THE OTHER TASKS OR WHAT WAS ACCOMPLISHED IN OTHER TASKS.
+
+ Pay attention to the way files are passed in the tasks, always use full paths. For example 'project/main.py'.
+
+ Make sure tasks are not duplicated.
+
+ Do not take long and complex routes, minimize tasks and steps as much as possible.
+
+ Here is a sample JSON output for a checklist:
+
+ {{
+ "tasks": [
+ {{
+ "id": 1,
+ "description": "Run a command to create the project directory named 'project'",
+ "file_path": "./project",
+ }},
+ {{
+ "id": 2,
+ "description": "Run a command to Install the following dependencies: 'numpy', 'pandas', 'scikit-learn', 'matplotlib'",
+ "file_path": "null",
+ }},
+ {{
+ "id": 3,
+ "description": "Write code to create a function named 'parser' that takes an input named 'input' of type str, [perform a specific task on it], and returns a specific output",
+ "file_path": "./project/main.py",
+ }},
+ ...
+ {{
+ "id": N,
+ "description": "...",
+ }}
+ ],
+ }}
+
+ The tasks will be executed by either of the three agents: command_executor, code_writer or code_refactor. They can't interact with programs. They can either run terminal commands or write code snippets. Their output is controlled by other functions to run the commands or save their output to code files. Make sure the tasks are compatible with the current agents. ALL tasks MUST start either with the following phrases: 'Run a command to...', 'Write code to...', 'Edit existing code to...' depending on the agent that will execute the task. RETURN JSON ONLY:"""
+
+ return openai_call(prompt, temperature=0.8, max_tokens=2000)
+
+def code_tasks_refactor_agent(objective: str, task_list_json):
+ prompt = f"""You are an AGI tasks_refactor_agent responsible for adapting a task list generated by another agent to ensure the tasks are compatible with the current AGI agents. Your goal is to analyze the task list and make necessary modifications so that the tasks can be executed by the agents listed below
+
+ YOU SHOULD OUTPUT THE MODIFIED TASK LIST IN THE SAME JSON FORMAT AS THE INITIAL TASK LIST. DO NOT CHANGE THE FORMAT OF THE JSON OUTPUT. DO NOT WRITE ANYTHING OTHER THAN THE MODIFIED TASK LIST IN THE JSON FORMAT.
+
+ The current agents work as follows:
+ - code_writer_agent: Writes code snippets or functions and saves them to the appropriate files. This agent can also append code to existing files if required.
+ - code_refactor_agent: Responsible for editing current existing code/files.
+ - command_executor_agent: Executes terminal commands for tasks such as creating directories, installing dependencies, etc.
+
+ Here is the overall objective you need to refactor the tasks for: {objective}.
+ Here is the JSON task list you need to refactor for compatibility with the current agents: {task_list_json}.
+
+ To refactor the task list, follow these steps:
+ 1. Modify the task descriptions to make them compatible with the current agents, ensuring that the tasks are self-contained, clear, and executable by the agents without additional context. You don't need to mention the agents in the task descriptions, but the tasks should be compatible with the current agents.
+ 2. If necessary, add new tasks or remove irrelevant tasks to make the task list more suitable for the current agents.
+ 3. Keep the JSON structure of the task list intact, maintaining the "id", "description" and "file_path" fields for each task.
+ 4. Pay close attention to the objective and make sure the tasks implement all necessary pieces needed to make the program work.
+
+ Always specify file paths to files. Make sure tasks are not duplicated. Never write code to create files. If needed, use commands to create files and folders.
+ Return the updated JSON task list with the following format:
+
+ {{
+ "tasks": [
+ {{
+ "id": 1,
+ "description": "Run a commmand to create a folder named 'project' in the current directory",
+ "file_path": "./project",
+ }},
+ {{
+ "id": 2,
+ "description": "Write code to print 'Hello World!' with Python",
+ "file_path": "./project/main.py",
+ }},
+ {{
+ "id": 3,
+ "description": "Write code to create a function named 'parser' that takes an input named 'input' of type str, [perform a specific task on it], and returns a specific output",
+ "file_path": "./project/main.py",
+ }}
+ {{
+ "id": 3,
+ "description": "Run a command calling the script in ./project/main.py",
+ "file_path": "./project/main.py",
+ }}
+ ...
+ ],
+ }}
+
+ IMPORTANT: All tasks should start either with the following phrases: 'Run a command to...', 'Write a code to...', 'Edit the code to...' depending on the agent that will execute the task:
+
+ ALWAYS ENSURE ALL TASKS HAVE RELEVANT CONTEXT ABOUT THE CODE TO BE WRITTEN, INCLUDE DETAILS ON HOW TO CALL FUNCTIONS, CLASSES, IMPORTS, ETC. AGENTS HAVE NO VIEW OF OTHER TASKS, SO THEY NEED TO BE SELF-CONTAINED. RETURN THE JSON:"""
+
+ return openai_call(prompt, temperature=0, max_tokens=2000)
+
+def code_tasks_details_agent(objective: str, task_list_json):
+ prompt = f"""You are an AGI agent responsible for improving a list of tasks in JSON format and adding ALL the necessary details to each task. These tasks will be executed individually by agents that have no idea about other tasks or what code exists in the codebase. It is FUNDAMENTAL that each task has enough details so that an individual isolated agent can execute. The metadata of the task is the only information the agents will have.
+
+ Each task should contain the details necessary to execute it. For example, if it creates a function, it needs to contain the details about the arguments to be used in that function and this needs to be consistent across all tasks.
+
+ Look at all tasks at once, and update the task description adding details to it for each task so that it can be executed by an agent without seeing the other tasks and to ensure consistency across all tasks. DETAILS ARE CRUCIAL. For example, if one task creates a class, it should have all the details about the class, including the arguments to be used in the constructor. If another task creates a function that uses the class, it should have the details about the class and the arguments to be used in the constructor.
+
+ RETURN JSON OUTPUTS ONLY.
+
+ Here is the overall objective you need to refactor the tasks for: {objective}.
+ Here is the task list you need to improve: {task_list_json}
+
+ RETURN THE SAME TASK LIST but with the description improved to contain the details you is adding for each task in the list. DO NOT MAKE OTHER MODIFICATIONS TO THE LIST. Your input should go in the 'description' field of each task.
+
+ RETURN JSON ONLY:"""
+ return openai_call(prompt, temperature=0.7, max_tokens=2000)
+
+def code_tasks_context_agent(objective: str, task_list_json):
+ prompt = f"""You are an AGI agent responsible for improving a list of tasks in JSON format and adding ALL the necessary context to it. These tasks will be executed individually by agents that have no idea about other tasks or what code exists in the codebase. It is FUNDAMENTAL that each task has enough context so that an individual isolated agent can execute. The metadata of the task is the only information the agents will have.
+
+ Look at all tasks at once, and add the necessary context to each task so that it can be executed by an agent without seeing the other tasks. Remember, one agent can only see one task and has no idea about what happened in other tasks. CONTEXT IS CRUCIAL. For example, if one task creates one folder and the other tasks creates a file in that folder. The second tasks should contain the name of the folder that already exists and the information that it already exists.
+
+ This is even more important for tasks that require importing functions, classes, etc. If a task needs to call a function or initialize a Class, it needs to have the detailed arguments, etc.
+
+ Note that you should identify when imports need to happen and specify this in the context. Also, you should identify when functions/classes/etc already exist and specify this very clearly because the agents sometimes duplicate things not knowing.
+
+ Always use imports with the file name. For example, 'from my_script import MyScript'.
+
+ RETURN JSON OUTPUTS ONLY.
+
+ Here is the overall objective you need to refactor the tasks for: {objective}.
+ Here is the task list you need to improve: {task_list_json}
+
+ RETURN THE SAME TASK LIST but with a new field called 'isolated_context' for each task in the list. This field should be a string with the context you are adding. DO NOT MAKE OTHER MODIFICATIONS TO THE LIST.
+
+ RETURN JSON ONLY:"""
+ return openai_call(prompt, temperature=0.7, max_tokens=2000)
+
+def task_assigner_recommendation_agent(objective: str, task: str):
+ prompt = f"""You are an AGI agent responsible for providing recommendations on which agent should be used to handle a specific task. Analyze the provided major objective of the project and a single task from the JSON checklist generated by the previous agent, and suggest the most appropriate agent to work on the task.
+
+ The overall objective is: {objective}
+ The current task is: {task}
+
+ The available agents are:
+ 1. code_writer_agent: Responsible for writing code based on the task description.
+ 2. code_refactor_agent: Responsible for editing existing code.
+ 3. command_executor_agent: Responsible for executing commands and handling file operations, such as creating, moving, or deleting files.
+
+ When analyzing the task, consider the following tips:
+ - Pay attention to keywords in the task description that indicate the type of action required, such as "write", "edit", "run", "create", "move", or "delete".
+ - Keep the overall objective in mind, as it can help you understand the context of the task and guide your choice of agent.
+ - If the task involves writing new code or adding new functionality, consider using the code_writer_agent.
+ - If the task involves modifying or optimizing existing code, consider using the code_refactor_agent.
+ - If the task involves file operations, command execution, or running a script, consider using the command_executor_agent.
+
+ Based on the task and overall objective, suggest the most appropriate agent to work on the task."""
+ return openai_call(prompt, temperature=0.5, max_tokens=2000)
+
+def task_assigner_agent(objective: str, task: str, recommendation: str):
+ prompt = f"""You are an AGI agent responsible for choosing the best agent to work on a given task. Your goal is to analyze the provided major objective of the project and a single task from the JSON checklist generated by the previous agent, and choose the best agent to work on the task.
+
+ The overall objective is: {objective}
+ The current task is: {task}
+
+ Use this recommendation to guide you: {recommendation}
+
+ The available agents are:
+ 1. code_writer_agent: Responsible for writing code based on the task description.
+ 2. code_refactor_agent: Responsible for editing existing code.
+ 2. command_executor_agent: Responsible for executing commands and handling file operations, such as creating, moving, or deleting files.
+
+ Please consider the task description and the overall objective when choosing the most appropriate agent. Keep in mind that creating a file and writing code are different tasks. If the task involves creating a file, like "calculator.py" but does not mention writing any code inside it, the command_executor_agent should be used for this purpose. The code_writer_agent should only be used when the task requires writing or adding code to a file. The code_refactor_agent should only be used when the task requires modifying existing code.
+
+ TLDR: To create files, use command_executor_agent, to write text/code to files, use code_writer_agent, to modify existing code, use code_refactor_agent.
+
+ Choose the most appropriate agent to work on the task and return a JSON output with the following format: {{"agent": "agent_name"}}. ONLY return JSON output:"""
+ return openai_call(prompt, temperature=0, max_tokens=2000)
+
+def command_executor_agent(task: str, file_path: str):
+ prompt = f"""You are an AGI agent responsible for executing a given command on the {os_version} OS. Your goal is to analyze the provided major objective of the project and a single task from the JSON checklist generated by the previous agent, and execute the command on the {os_version} OS.
+
+ The current task is: {task}
+ File or folder name referenced in the task (relative file path): {file_path}
+
+ Based on the task, write the appropriate command to execute on the {os_version} OS. Make sure the command is relevant to the task and objective. For example, if the task is to create a new folder, the command should be 'mkdir new_folder_name'. Return the command as a JSON output with the following format: {{"command": "command_to_execute"}}. ONLY return JSON output:"""
+ return openai_call(prompt, temperature=0, max_tokens=2000)
+
+def code_writer_agent(task: str, isolated_context: str, context_code_chunks):
+ prompt = f"""You are an AGI agent responsible for writing code to accomplish a given task. Your goal is to analyze the provided major objective of the project and a single task from the JSON checklist generated by the previous agent, and write the necessary code to complete the task.
+
+ The current task is: {task}
+
+ To help you make the code useful in this codebase, use this context as reference of the other pieces of the codebase that are relevant to your task. PAY ATTENTION TO THIS: {isolated_context}
+
+ The following code chunks were found to be relevant to the task. You can use them as reference to write the code if they are useful. PAY CLOSE ATTENTION TO THIS:
+ {context_code_chunks}
+
+ Note: Always use 'encoding='utf-8'' when opening files with open().
+
+ Based on the task and objective, write the appropriate code to achieve the task. Make sure the code is relevant to the task and objective, and follows best practices. Return the code as a plain text output and NOTHING ELSE. Use identation and line breaks in the in the code. Make sure to only write the code and nothing else as your output will be saved directly to the file by other agent. IMPORTANT" If the task is asking you to write code to write files, this is a mistake! Interpret it and either do nothing or return the plain code, not a code to write file, not a code to write code, etc."""
+ return openai_call(prompt, temperature=0, max_tokens=2000)
+
+def code_refactor_agent(task_description: str, existing_code_snippet: str, context_chunks, isolated_context: str):
+
+ prompt = f"""You are an AGI agent responsible for refactoring code to accomplish a given task. Your goal is to analyze the provided major objective of the project, the task descriptionm and refactor the code accordingly.
+
+ The current task description is: {task_description}
+ To help you make the code useful in this codebase, use this context as reference of the other pieces of the codebase that are relevant to your task: {isolated_context}
+
+ Here are some context chunks that might be relevant to the task:
+ {context_chunks}
+
+ Existing code you should refactor:
+ {existing_code_snippet}
+
+ Based on the task description, objective, refactor the existing code to achieve the task. Make sure the refactored code is relevant to the task and objective, follows best practices, etc.
+
+ Return a plain text code snippet with your refactored code. IMPORTANT: JUST RETURN CODE, YOUR OUTPUT WILL BE ADDED DIRECTLY TO THE FILE BY OTHER AGENT. BE MINDFUL OF THIS:"""
+
+ return openai_call(prompt, temperature=0, max_tokens=2000)
+
+def file_management_agent(objective: str, task: str, current_directory_files: str, file_path: str):
+ prompt = f"""You are an AGI agent responsible for managing files in a software project. Your goal is to analyze the provided major objective of the project and a single task from the JSON checklist generated by the previous agent, and determine the appropriate file path and name for the generated code.
+
+ The overall objective is: {objective}
+ The current task is: {task}
+ Specified file path (relative path from the current dir): {file_path}
+
+ Make the file path adapted for the current directory files. The current directory files are: {current_directory_files}. Assume this file_path will be interpreted from the root path of the directory.
+
+ Do not use '.' or './' in the file path.
+
+ BE VERY SPECIFIC WITH THE FILES, AVOID FILE DUPLICATION, AVOID SPECIFYING THE SAME FILE NAME UNDER DIFFERENT FOLDERS, ETC.
+
+ Based on the task, determine the file path and name for the generated code. Return the file path and name as a JSON output with the following format: {{"file_path": "file_path_and_name"}}. ONLY return JSON output:"""
+ return openai_call(prompt, temperature=0, max_tokens=2000)
+
+def code_relevance_agent(objective: str, task_description: str, code_chunk: str):
+ prompt = f"""You are an AGI agent responsible for evaluating the relevance of a code chunk in relation to a given task. Your goal is to analyze the provided major objective of the project, the task description, and the code chunk, and assign a relevance score from 0 to 10, where 0 is completely irrelevant and 10 is highly relevant.
+
+ The overall objective is: {objective}
+ The current task description is: {task_description}
+ The code chunk is as follows (line numbers included):
+ {code_chunk}
+
+ Based on the task description, objective, and code chunk, assign a relevance score between 0 and 10 (inclusive) for the code chunk. DO NOT OUTPUT ANYTHING OTHER THAN THE RELEVANCE SCORE AS A NUMBER."""
+
+ relevance_score = openai_call(prompt, temperature=0.5, max_tokens=50)
+
+ return json.dumps({"relevance_score": relevance_score.strip()})
+
+def task_human_input_agent(task: str, human_feedback: str):
+ prompt = f"""You are an AGI agent responsible for getting human input to improve the quality of tasks in a software project. Your goal is to analyze the provided task and adapt it based on the human's suggestions. The tasks should start with either 'Run a command to...', 'Write code to...', or 'Edit existing code to...' depending on the agent that will execute the task.
+
+ For context, this task will be executed by other AGI agents with the following characteristics:
+ - code_writer_agent: Writes code snippets or functions and saves them to the appropriate files. This agent can also append code to existing files if required.
+ - code_refactor_agent: Responsible for modifying and refactoring existing code to meet the requirements of the task.
+ - command_executor_agent: Executes terminal commands for tasks such as creating directories, installing dependencies, etc.
+
+ The current task is:
+ {task}
+
+ The human feedback is:
+ {human_feedback}
+
+ If the human feedback is empty, return the task as is. If the human feedback is saying to ignore the task, return the following string:
+
+ Note that your output will replace the existing task, so make sure that your output is a valid task that starts with one of the required phrases ('Run a command to...', 'Write code to...', 'Edit existing code to...').
+
+ Please adjust the task based on the human feedback while ensuring it starts with one of the required phrases ('Run a command to...', 'Write code to...', 'Edit existing code to...'). Return the improved task as a plain text output and nothing else. Write only the new task."""
+
+ return openai_call(prompt, temperature=0.3, max_tokens=200)
+
+## END OF AGENTS ##
+
+print_colored_text(f"****Objective****", color='green')
+print_char_by_char(OBJECTIVE, 0.00001, 10)
+
+# Create the tasks
+print_colored_text("*****Working on tasks*****", "red")
+print_colored_text(" - Creating initial tasks", "yellow")
+task_agent_output = code_tasks_initializer_agent(OBJECTIVE)
+print_colored_text(" - Reviewing and refactoring tasks to fit agents", "yellow")
+task_agent_output = code_tasks_refactor_agent(OBJECTIVE, task_agent_output)
+print_colored_text(" - Adding relevant technical details to the tasks", "yellow")
+task_agent_output = code_tasks_details_agent(OBJECTIVE, task_agent_output)
+print_colored_text(" - Adding necessary context to the tasks", "yellow")
+task_agent_output = code_tasks_context_agent(OBJECTIVE, task_agent_output)
+print()
+
+print_colored_text("*****TASKS*****", "green")
+print_char_by_char(task_agent_output, 0.00000001, 10)
+
+# Task list
+task_json = json.loads(task_agent_output)
+
+embeddings = Embeddings(current_directory)
+
+for task in task_json["tasks"]:
+ task_description = task["description"]
+ task_isolated_context = task["isolated_context"]
+
+ print_colored_text("*****TASK*****", "yellow")
+ print_char_by_char(task_description)
+ print_colored_text("*****TASK CONTEXT*****", "yellow")
+ print_char_by_char(task_isolated_context)
+
+ # HUMAN FEEDBACK
+ # Uncomment below to enable human feedback before each task. This can be used to improve the quality of the tasks,
+ # skip tasks, etc. I believe it may be very relevant in future versions that may have more complex tasks and could
+ # allow a ton of automation when working on large projects.
+ #
+ # Get user input as a feedback to the task_description
+ # print_colored_text("*****TASK FEEDBACK*****", "yellow")
+ # user_input = input("\n>:")
+ # task_description = task_human_input_agent(task_description, user_input)
+ # if task_description == "":
+ # continue
+ # print_colored_text("*****IMPROVED TASK*****", "green")
+ # print_char_by_char(task_description)
+
+ # Assign the task to an agent
+ task_assigner_recommendation = task_assigner_recommendation_agent(OBJECTIVE, task_description)
+ task_agent_output = task_assigner_agent(OBJECTIVE, task_description, task_assigner_recommendation)
+
+ print_colored_text("*****ASSIGN*****", "yellow")
+ print_char_by_char(task_agent_output)
+
+ chosen_agent = json.loads(task_agent_output)["agent"]
+
+ if chosen_agent == "command_executor_agent":
+ command_executor_output = command_executor_agent(task_description, task["file_path"])
+ print_colored_text("*****COMMAND*****", "green")
+ print_char_by_char(command_executor_output)
+
+ command_execution_output = execute_command_json(command_executor_output)
+ else:
+ # CODE AGENTS
+ if chosen_agent == "code_writer_agent":
+ # Compute embeddings for the codebase
+ # This will recompute embeddings for all files in the 'playground' directory
+ print_colored_text("*****RETRIEVING RELEVANT CODE CONTEXT*****", "yellow")
+ embeddings.compute_repository_embeddings()
+ relevant_chunks = embeddings.get_relevant_code_chunks(task_description, task_isolated_context)
+
+ current_directory_files = execute_command_string("ls")
+ file_management_output = file_management_agent(OBJECTIVE, task_description, current_directory_files, task["file_path"])
+ print_colored_text("*****FILE MANAGEMENT*****", "yellow")
+ print_char_by_char(file_management_output)
+ file_path = json.loads(file_management_output)["file_path"]
+
+ code_writer_output = code_writer_agent(task_description, task_isolated_context, relevant_chunks)
+
+ print_colored_text("*****CODE*****", "green")
+ print_char_by_char(code_writer_output)
+
+ # Save the generated code to the file the agent selected
+ save_code_to_file(code_writer_output, file_path)
+
+ elif chosen_agent == "code_refactor_agent":
+ # The code refactor agent works with multiple agents:
+ # For each task, the file_management_agent is used to select the file to edit.Then, the
+ # code_relevance_agent is used to select the relevant code chunks from that filewith the
+ # goal of finding the code chunk that is most relevant to the task description. This is
+ # the code chunk that will be edited. Finally, the code_refactor_agent is used to edit
+ # the code chunk.
+
+ current_directory_files = execute_command_string("ls")
+ file_management_output = file_management_agent(OBJECTIVE, task_description, current_directory_files, task["file_path"])
+ file_path = json.loads(file_management_output)["file_path"]
+
+ print_colored_text("*****FILE MANAGEMENT*****", "yellow")
+ print_char_by_char(file_management_output)
+
+ # Split the code into chunks and get the relevance scores for each chunk
+ code_chunks = split_code_into_chunks(file_path, 80)
+ print_colored_text("*****ANALYZING EXISTING CODE*****", "yellow")
+ relevance_scores = []
+ for chunk in code_chunks:
+ score = code_relevance_agent(OBJECTIVE, task_description, chunk["code"])
+ relevance_scores.append(score)
+
+ # Select the most relevant chunk
+ selected_chunk = sorted(zip(relevance_scores, code_chunks), key=lambda x: x[0], reverse=True)[0][1]
+
+ # Refactor the code
+ modified_code_output = code_refactor_agent(task_description, selected_chunk, context_chunks=[selected_chunk], isolated_context=task_isolated_context)
+
+ # Extract the start_line and end_line of the selected chunk. This will be used to replace the code in the original file
+ start_line = selected_chunk["start_line"]
+ end_line = selected_chunk["end_line"]
+
+ # Count the number of lines in the modified_code_output
+ modified_code_lines = modified_code_output.count("\n") + 1
+ # Create a dictionary with the necessary information for the refactor_code function
+ modified_code_info = {
+ "start_line": start_line,
+ "end_line": start_line + modified_code_lines - 1,
+ "modified_code": modified_code_output
+ }
+ print_colored_text("*****REFACTORED CODE*****", "green")
+ print_char_by_char(modified_code_output)
+
+ # Save the refactored code to the file
+ refactor_code([modified_code_info], file_path)
diff --git a/babycoder/embeddings.py b/babycoder/embeddings.py
new file mode 100644
index 00000000..1025b793
--- /dev/null
+++ b/babycoder/embeddings.py
@@ -0,0 +1,207 @@
+import os
+import csv
+import shutil
+import openai
+import pandas as pd
+import numpy as np
+from transformers import GPT2TokenizerFast
+from dotenv import load_dotenv
+import time
+
+# Heavily derived from OpenAi's cookbook example
+
+load_dotenv()
+
+# the dir is the ./playground directory
+REPOSITORY_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "playground")
+
+class Embeddings:
+ def __init__(self, workspace_path: str):
+ self.workspace_path = workspace_path
+ openai.api_key = os.getenv("OPENAI_API_KEY", "")
+
+ self.DOC_EMBEDDINGS_MODEL = f"text-embedding-ada-002"
+ self.QUERY_EMBEDDINGS_MODEL = f"text-embedding-ada-002"
+
+ self.SEPARATOR = "\n* "
+
+ self.tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
+ self.separator_len = len(self.tokenizer.tokenize(self.SEPARATOR))
+
+ def compute_repository_embeddings(self):
+ try:
+ playground_data_path = os.path.join(self.workspace_path, 'playground_data')
+
+ # Delete the contents of the playground_data directory but not the directory itself
+ # This is to ensure that we don't have any old data lying around
+ for filename in os.listdir(playground_data_path):
+ file_path = os.path.join(playground_data_path, filename)
+
+ try:
+ if os.path.isfile(file_path) or os.path.islink(file_path):
+ os.unlink(file_path)
+ elif os.path.isdir(file_path):
+ shutil.rmtree(file_path)
+ except Exception as e:
+ print(f"Failed to delete {file_path}. Reason: {str(e)}")
+ except Exception as e:
+ print(f"Error: {str(e)}")
+
+ # extract and save info to csv
+ info = self.extract_info(REPOSITORY_PATH)
+ self.save_info_to_csv(info)
+
+ df = pd.read_csv(os.path.join(self.workspace_path, 'playground_data\\repository_info.csv'))
+ df = df.set_index(["filePath", "lineCoverage"])
+ self.df = df
+ context_embeddings = self.compute_doc_embeddings(df)
+ self.save_doc_embeddings_to_csv(context_embeddings, df, os.path.join(self.workspace_path, 'playground_data\\doc_embeddings.csv'))
+
+ try:
+ self.document_embeddings = self.load_embeddings(os.path.join(self.workspace_path, 'playground_data\\doc_embeddings.csv'))
+ except:
+ pass
+
+ # Extract information from files in the repository in chunks
+ # Return a list of [filePath, lineCoverage, chunkContent]
+ def extract_info(self, REPOSITORY_PATH):
+ # Initialize an empty list to store the information
+ info = []
+
+ LINES_PER_CHUNK = 60
+
+ # Iterate through the files in the repository
+ for root, dirs, files in os.walk(REPOSITORY_PATH):
+ for file in files:
+ file_path = os.path.join(root, file)
+
+ # Read the contents of the file
+ with open(file_path, "r", encoding="utf-8") as f:
+ try:
+ contents = f.read()
+ except:
+ continue
+
+ # Split the contents into lines
+ lines = contents.split("\n")
+ # Ignore empty lines
+ lines = [line for line in lines if line.strip()]
+ # Split the lines into chunks of LINES_PER_CHUNK lines
+ chunks = [
+ lines[i:i+LINES_PER_CHUNK]
+ for i in range(0, len(lines), LINES_PER_CHUNK)
+ ]
+ # Iterate through the chunks
+ for i, chunk in enumerate(chunks):
+ # Join the lines in the chunk back into a single string
+ chunk = "\n".join(chunk)
+ # Get the first and last line numbers
+ first_line = i * LINES_PER_CHUNK + 1
+ last_line = first_line + len(chunk.split("\n")) - 1
+ line_coverage = (first_line, last_line)
+ # Add the file path, line coverage, and content to the list
+ info.append((os.path.join(root, file), line_coverage, chunk))
+
+ # Return the list of information
+ return info
+
+ def save_info_to_csv(self, info):
+ # Open a CSV file for writing
+ os.makedirs(os.path.join(self.workspace_path, "playground_data"), exist_ok=True)
+ with open(os.path.join(self.workspace_path, 'playground_data\\repository_info.csv'), "w", newline="") as csvfile:
+ # Create a CSV writer
+ writer = csv.writer(csvfile)
+ # Write the header row
+ writer.writerow(["filePath", "lineCoverage", "content"])
+ # Iterate through the info
+ for file_path, line_coverage, content in info:
+ # Write a row for each chunk of data
+ writer.writerow([file_path, line_coverage, content])
+
+ def get_relevant_code_chunks(self, task_description: str, task_context: str):
+ query = task_description + "\n" + task_context
+ most_relevant_document_sections = self.order_document_sections_by_query_similarity(query, self.document_embeddings)
+ selected_chunks = []
+ for _, section_index in most_relevant_document_sections:
+ try:
+ document_section = self.df.loc[section_index]
+ selected_chunks.append(self.SEPARATOR + document_section['content'].replace("\n", " "))
+ if len(selected_chunks) >= 2:
+ break
+ except:
+ pass
+
+ return selected_chunks
+
+ def get_embedding(self, text: str, model: str) -> list[float]:
+ result = openai.Embedding.create(
+ model=model,
+ input=text
+ )
+ return result["data"][0]["embedding"]
+
+ def get_doc_embedding(self, text: str) -> list[float]:
+ return self.get_embedding(text, self.DOC_EMBEDDINGS_MODEL)
+
+ def get_query_embedding(self, text: str) -> list[float]:
+ return self.get_embedding(text, self.QUERY_EMBEDDINGS_MODEL)
+
+ def compute_doc_embeddings(self, df: pd.DataFrame) -> dict[tuple[str, str], list[float]]:
+ """
+ Create an embedding for each row in the dataframe using the OpenAI Embeddings API.
+
+ Return a dictionary that maps between each embedding vector and the index of the row that it corresponds to.
+ """
+ embeddings = {}
+ for idx, r in df.iterrows():
+ # Wait one second before making the next call to the OpenAI Embeddings API
+ # print("Waiting one second before embedding next row\n")
+ time.sleep(1)
+ embeddings[idx] = self.get_doc_embedding(r.content.replace("\n", " "))
+ return embeddings
+
+ def save_doc_embeddings_to_csv(self, doc_embeddings: dict, df: pd.DataFrame, csv_filepath: str):
+ # Get the dimensionality of the embedding vectors from the first element in the doc_embeddings dictionary
+ if len(doc_embeddings) == 0:
+ return
+
+ EMBEDDING_DIM = len(list(doc_embeddings.values())[0])
+
+ # Create a new dataframe with the filePath, lineCoverage, and embedding vector columns
+ embeddings_df = pd.DataFrame(columns=["filePath", "lineCoverage"] + [f"{i}" for i in range(EMBEDDING_DIM)])
+
+ # Iterate over the rows in the original dataframe
+ for idx, _ in df.iterrows():
+ # Get the embedding vector for the current row
+ embedding = doc_embeddings[idx]
+ # Create a new row in the embeddings dataframe with the filePath, lineCoverage, and embedding vector values
+ row = [idx[0], idx[1]] + embedding
+ embeddings_df.loc[len(embeddings_df)] = row
+
+ # Save the embeddings dataframe to a CSV file
+ embeddings_df.to_csv(csv_filepath, index=False)
+
+ def vector_similarity(self, x: list[float], y: list[float]) -> float:
+ return np.dot(np.array(x), np.array(y))
+
+ def order_document_sections_by_query_similarity(self, query: str, contexts: dict[(str, str), np.array]) -> list[(float, (str, str))]:
+ """
+ Find the query embedding for the supplied query, and compare it against all of the pre-calculated document embeddings
+ to find the most relevant sections.
+
+ Return the list of document sections, sorted by relevance in descending order.
+ """
+ query_embedding = self.get_query_embedding(query)
+
+ document_similarities = sorted([
+ (self.vector_similarity(query_embedding, doc_embedding), doc_index) for doc_index, doc_embedding in contexts.items()
+ ], reverse=True)
+
+ return document_similarities
+
+ def load_embeddings(self, fname: str) -> dict[tuple[str, str], list[float]]:
+ df = pd.read_csv(fname, header=0)
+ max_dim = max([int(c) for c in df.columns if c != "filePath" and c != "lineCoverage"])
+ return {
+ (r.filePath, r.lineCoverage): [r[str(i)] for i in range(max_dim + 1)] for _, r in df.iterrows()
+ }
\ No newline at end of file
diff --git a/babycoder/objective.sample.txt b/babycoder/objective.sample.txt
new file mode 100644
index 00000000..8bf59cb3
--- /dev/null
+++ b/babycoder/objective.sample.txt
@@ -0,0 +1,6 @@
+Create a Python program that consists of a single class named 'TemperatureConverter' in a file named 'temperature_converter.py'. The class should have the following methods:
+
+- celsius_to_fahrenheit(self, celsius: float) -> float: Converts Celsius temperature to Fahrenheit.
+- fahrenheit_to_celsius(self, fahrenheit: float) -> float: Converts Fahrenheit temperature to Celsius.
+
+Create a separate 'main.py' file that imports the 'TemperatureConverter' class, takes user input for the temperature value and the unit, converts the temperature to the other unit, and then prints the result.
\ No newline at end of file
diff --git a/babycoder/playground/noop.md b/babycoder/playground/noop.md
new file mode 100644
index 00000000..9937907a
--- /dev/null
+++ b/babycoder/playground/noop.md
@@ -0,0 +1 @@
+# noop
\ No newline at end of file
diff --git a/classic/ABOUT.md b/classic/ABOUT.md
new file mode 100644
index 00000000..a68f2115
--- /dev/null
+++ b/classic/ABOUT.md
@@ -0,0 +1,3 @@
+# BabyAgi Classic
+
+This folder contains the classic version of BabyAGI as a single script. You can use this as a starting point for your own projects built on the original BabyAGI reasoning engine, if the mainline version is too complex for your needs.
\ No newline at end of file
diff --git a/classic/BabyBeeAGI.py b/classic/BabyBeeAGI.py
new file mode 100644
index 00000000..7768ad8a
--- /dev/null
+++ b/classic/BabyBeeAGI.py
@@ -0,0 +1,300 @@
+###### This is a modified version of OG BabyAGI, called BabyBeeAGI (future modifications will follow the pattern "BabyAGI"). This version requires GPT-4, it's very slow, and often errors out.######
+######IMPORTANT NOTE: I'm sharing this as a framework to build on top of (with lots of errors for improvement), to facilitate discussion around how to improve these. This is NOT for people who are looking for a complete solution that's ready to use. ######
+
+import openai
+import pinecone
+import time
+import requests
+from bs4 import BeautifulSoup
+from collections import deque
+from typing import Dict, List
+import re
+import ast
+import json
+from serpapi import GoogleSearch
+
+### SET THESE 4 VARIABLES ##############################
+
+# Add your API keys here
+OPENAI_API_KEY = ""
+SERPAPI_API_KEY = "" #If you include SERPAPI KEY, this will enable web-search. If you don't, it will automatically remove web-search capability.
+
+# Set variables
+OBJECTIVE = "You are an AI. Make the world a better place."
+YOUR_FIRST_TASK = "Develop a task list."
+
+### UP TO HERE ##############################
+
+# Configure OpenAI and SerpAPI client
+openai.api_key = OPENAI_API_KEY
+if SERPAPI_API_KEY:
+ serpapi_client = GoogleSearch({"api_key": SERPAPI_API_KEY})
+ websearch_var = "[web-search] "
+else:
+ websearch_var = ""
+
+# Initialize task list
+task_list = []
+
+# Initialize session_summary
+session_summary = ""
+
+### Task list functions ##############################
+def add_task(task: Dict):
+ task_list.append(task)
+
+def get_task_by_id(task_id: int):
+ for task in task_list:
+ if task["id"] == task_id:
+ return task
+ return None
+
+def get_completed_tasks():
+ return [task for task in task_list if task["status"] == "complete"]
+
+### Tool functions ##############################
+def text_completion_tool(prompt: str):
+ response = openai.Completion.create(
+ engine="text-davinci-003",
+ prompt=prompt,
+ temperature=0.5,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+ return response.choices[0].text.strip()
+
+def web_search_tool(query: str):
+ search_params = {
+ "engine": "google",
+ "q": query,
+ "api_key": SERPAPI_API_KEY,
+ "num":3
+ }
+ search_results = GoogleSearch(search_params)
+ results = search_results.get_dict()
+
+ return str(results["organic_results"])
+
+def web_scrape_tool(url: str):
+ response = requests.get(url)
+ print(response)
+ soup = BeautifulSoup(response.content, "html.parser")
+ result = soup.get_text(strip=True)+"URLs: "
+ for link in soup.findAll('a', attrs={'href': re.compile("^https://")}):
+ result+= link.get('href')+", "
+ return result
+
+### Agent functions ##############################
+def execute_task(task, task_list, OBJECTIVE):
+ global task_id_counter
+ # Check if dependent_task_id is complete
+ if task["dependent_task_id"]:
+ dependent_task = get_task_by_id(task["dependent_task_id"])
+ if not dependent_task or dependent_task["status"] != "complete":
+ return
+
+ # Execute task
+
+ print("\033[92m\033[1m"+"\n*****NEXT TASK*****\n"+"\033[0m\033[0m")
+ print(str(task['id'])+": "+str(task['task'])+" ["+str(task['tool']+"]"))
+ task_prompt = f"Complete your assigned task based on the objective: {OBJECTIVE}. Your task: {task['task']}"
+ if task["dependent_task_id"]:
+ dependent_task_result = dependent_task["result"]
+ task_prompt += f"\nThe previous task ({dependent_task['id']}. {dependent_task['task']}) result: {dependent_task_result}"
+
+ task_prompt += "\nResponse:"
+ ##print("###task_prompt: "+task_prompt)
+ if task["tool"] == "text-completion":
+ result = text_completion_tool(task_prompt)
+ elif task["tool"] == "web-search":
+ result = web_search_tool(task_prompt)
+ elif task["tool"] == "web-scrape":
+ result = web_scrape_tool(str(task['task']))
+ else:
+ result = "Unknown tool"
+
+
+ print("\033[93m\033[1m"+"\n*****TASK RESULT*****\n"+"\033[0m\033[0m")
+ print_result = result[0:2000]
+ if result != result[0:2000]:
+ print(print_result+"...")
+ else:
+ print(result)
+ # Update task status and result
+ task["status"] = "complete"
+ task["result"] = result
+ task["result_summary"] = summarizer_agent(result)
+
+ # Update session_summary
+ session_summary = overview_agent(task["id"])
+
+ # Increment task_id_counter
+ task_id_counter += 1
+
+ # Update task_manager_agent of tasks
+ task_manager_agent(
+ OBJECTIVE,
+ result,
+ task["task"],
+ [t["task"] for t in task_list if t["status"] == "incomplete"],
+ task["id"]
+ )
+
+
+def task_manager_agent(objective: str, result: str, task_description: str, incomplete_tasks: List[str], current_task_id : int) -> List[Dict]:
+ global task_list
+ original_task_list = task_list.copy()
+ minified_task_list = [{k: v for k, v in task.items() if k != "result"} for task in task_list]
+ result = result[0:4000] #come up with better solution later.
+
+ prompt = (
+ f"You are a task management AI tasked with cleaning the formatting of and reprioritizing the following tasks: {minified_task_list}. "
+ f"Consider the ultimate objective of your team: {OBJECTIVE}. "
+ f"Do not remove any tasks. Return the result as a JSON-formatted list of dictionaries.\n"
+ f"Create new tasks based on the result of last task if necessary for the objective. Limit tasks types to those that can be completed with the available tools listed below. Task description should be detailed."
+ f"The maximum task list length is 7. Do not add an 8th task."
+ f"The last completed task has the following result: {result}. "
+ f"Current tool option is [text-completion] {websearch_var} and [web-scrape] only."# web-search is added automatically if SERPAPI exists
+ f"For tasks using [web-scrape], provide only the URL to scrape as the task description. Do not provide placeholder URLs, but use ones provided by a search step or the initial objective."
+ #f"If the objective is research related, use at least one [web-search] with the query as the task description, and after, add up to three URLs from the search result as a task with [web-scrape], then use [text-completion] to write a comprehensive summary of each site thas has been scraped.'"
+ f"For tasks using [web-search], provide the search query, and only the search query to use (eg. not 'research waterproof shoes, but 'waterproof shoes')"
+ f"dependent_task_id should always be null or a number."
+ f"Do not reorder completed tasks. Only reorder and dedupe incomplete tasks.\n"
+ f"Make sure all task IDs are in chronological order.\n"
+ f"Do not provide example URLs for [web-scrape].\n"
+ f"Do not include the result from the last task in the JSON, that will be added after..\n"
+ f"The last step is always to provide a final summary report of all tasks.\n"
+ f"An example of the desired output format is: "
+ "[{\"id\": 1, \"task\": \"https://untapped.vc\", \"tool\": \"web-scrape\", \"dependent_task_id\": null, \"status\": \"incomplete\", \"result\": null, \"result_summary\": null}, {\"id\": 2, \"task\": \"Analyze the contents of...\", \"tool\": \"text-completion\", \"dependent_task_id\": 1, \"status\": \"incomplete\", \"result\": null, \"result_summary\": null}, {\"id\": 3, \"task\": \"Untapped Capital\", \"tool\": \"web-search\", \"dependent_task_id\": null, \"status\": \"incomplete\", \"result\": null, \"result_summary\": null}]."
+ )
+ print("\033[90m\033[3m" + "\nRunning task manager agent...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-4",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task manager AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0.2,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print("\033[90m\033[3m" + "\nDone!\n" + "\033[0m")
+ try:
+ task_list = json.loads(result)
+ except Exception as error:
+ print(error)
+ # Add the 'result' field back in
+ for updated_task, original_task in zip(task_list, original_task_list):
+ if "result" in original_task:
+ updated_task["result"] = original_task["result"]
+ task_list[current_task_id]["result"]=result
+ #print(task_list)
+ return task_list
+
+
+
+def summarizer_agent(text: str) -> str:
+ text = text[0:4000]
+ prompt = f"Please summarize the following text:\n{text}\nSummary:"
+ response = openai.Completion.create(
+ engine="text-davinci-003",
+ prompt=prompt,
+ temperature=0.5,
+ max_tokens=100,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+ return response.choices[0].text.strip()
+
+
+def overview_agent(last_task_id: int) -> str:
+ global session_summary
+
+ completed_tasks = get_completed_tasks()
+ completed_tasks_text = "\n".join(
+ [f"{task['id']}. {task['task']} - {task['result_summary']}" for task in completed_tasks]
+ )
+
+ prompt = f"Here is the current session summary:\n{session_summary}\nThe last completed task is task {last_task_id}. Please update the session summary with the information of the last task:\n{completed_tasks_text}\nUpdated session summary, which should describe all tasks in chronological order:"
+ response = openai.Completion.create(
+ engine="text-davinci-003",
+ prompt=prompt,
+ temperature=0.5,
+ max_tokens=200,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+ session_summary = response.choices[0].text.strip()
+ return session_summary
+
+
+### Main Loop ##############################
+
+# Add the first task
+first_task = {
+ "id": 1,
+ "task": YOUR_FIRST_TASK,
+ "tool": "text-completion",
+ "dependent_task_id": None,
+ "status": "incomplete",
+ "result": "",
+ "result_summary": ""
+}
+add_task(first_task)
+
+task_id_counter = 0
+#Print OBJECTIVE
+print("\033[96m\033[1m"+"\n*****OBJECTIVE*****\n"+"\033[0m\033[0m")
+print(OBJECTIVE)
+
+# Continue the loop while there are incomplete tasks
+while any(task["status"] == "incomplete" for task in task_list):
+
+ # Filter out incomplete tasks
+ incomplete_tasks = [task for task in task_list if task["status"] == "incomplete"]
+
+ if incomplete_tasks:
+ # Sort tasks by ID
+ incomplete_tasks.sort(key=lambda x: x["id"])
+
+ # Pull the first task
+ task = incomplete_tasks[0]
+
+ # Execute task & call task manager from function
+ execute_task(task, task_list, OBJECTIVE)
+
+ # Print task list and session summary
+ print("\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m")
+ for t in task_list:
+ dependent_task = ""
+ if t['dependent_task_id'] is not None:
+ dependent_task = f"\033[31m\033[0m"
+ status_color = "\033[32m" if t['status'] == "complete" else "\033[31m"
+ print(f"\033[1m{t['id']}\033[0m: {t['task']} {status_color}[{t['status']}]\033[0m \033[93m[{t['tool']}] {dependent_task}\033[0m")
+ print("\033[93m\033[1m" + "\n*****SESSION SUMMARY*****\n" + "\033[0m\033[0m")
+ print(session_summary)
+
+ time.sleep(1) # Sleep before checking the task list again
+
+### Objective complete ##############################
+
+# Print the full task list if there are no incomplete tasks
+if all(task["status"] != "incomplete" for task in task_list):
+ print("\033[92m\033[1m" + "\n*****ALL TASKS COMPLETED*****\n" + "\033[0m\033[0m")
+ for task in task_list:
+ print(f"ID: {task['id']}, Task: {task['task']}, Result: {task['result']}")
diff --git a/classic/BabyCatAGI.py b/classic/BabyCatAGI.py
new file mode 100644
index 00000000..42b3dad2
--- /dev/null
+++ b/classic/BabyCatAGI.py
@@ -0,0 +1,320 @@
+###### This is a modified version of OG BabyAGI, called BabyCatAGI (future modifications will follow the pattern "BabyAGI"). This version requires GPT-4, it's very slow, and often errors out.######
+######IMPORTANT NOTE: I'm sharing this as a framework to build on top of (with lots of errors for improvement), to facilitate discussion around how to improve these. This is NOT for people who are looking for a complete solution that's ready to use. ######
+
+import openai
+import time
+import requests
+from bs4 import BeautifulSoup
+from collections import deque
+from typing import Dict, List
+import re
+import ast
+import json
+from serpapi import GoogleSearch
+
+### SET THESE 4 VARIABLES ##############################
+
+# Add your API keys here
+OPENAI_API_KEY = ""
+SERPAPI_API_KEY = "" #If you include SERPAPI KEY, this will enable web-search. If you don't, it will autoatically remove web-search capability.
+
+# Set variables
+OBJECTIVE = "Research experts at scaling NextJS and their Twitter accounts."
+YOUR_FIRST_TASK = "Develop a task list." #you can provide additional instructions here regarding the task list.
+
+### UP TO HERE ##############################
+
+# Configure OpenAI and SerpAPI client
+openai.api_key = OPENAI_API_KEY
+if SERPAPI_API_KEY:
+ serpapi_client = GoogleSearch({"api_key": SERPAPI_API_KEY})
+ websearch_var = "[web-search] "
+else:
+ websearch_var = ""
+
+# Initialize task list
+task_list = []
+
+# Initialize session_summary
+session_summary = ""
+
+### Task list functions ##############################
+def add_task(task: Dict):
+ task_list.append(task)
+
+def get_task_by_id(task_id: int):
+ for task in task_list:
+ if task["id"] == task_id:
+ return task
+ return None
+
+def get_completed_tasks():
+ return [task for task in task_list if task["status"] == "complete"]
+
+
+# Print task list and session summary
+def print_tasklist():
+ print("\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m")
+ for t in task_list:
+ dependent_task = ""
+ if t['dependent_task_ids']:
+ dependent_task = f"\033[31m\033[0m"
+ status_color = "\033[32m" if t['status'] == "complete" else "\033[31m"
+ print(f"\033[1m{t['id']}\033[0m: {t['task']} {status_color}[{t['status']}]\033[0m \033[93m[{t['tool']}] {dependent_task}\033[0m")
+
+### Tool functions ##############################
+def text_completion_tool(prompt: str):
+ messages = [
+ {"role": "user", "content": prompt}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.2,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+def web_search_tool(query: str):
+ search_params = {
+ "engine": "google",
+ "q": query,
+ "api_key": SERPAPI_API_KEY,
+ "num":5 #edit this up or down for more results, though higher often results in OpenAI rate limits
+ }
+ search_results = GoogleSearch(search_params)
+ search_results = search_results.get_dict()
+ try:
+ search_results = search_results["organic_results"]
+ except:
+ search_results = {}
+ search_results = simplify_search_results(search_results)
+ print("\033[90m\033[3m" + "Completed search. Now scraping results.\n" + "\033[0m")
+ results = "";
+ # Loop through the search results
+ for result in search_results:
+ # Extract the URL from the result
+ url = result.get('link')
+ # Call the web_scrape_tool function with the URL
+ print("\033[90m\033[3m" + "Scraping: "+url+"" + "...\033[0m")
+ content = web_scrape_tool(url, task)
+ print("\033[90m\033[3m" +str(content[0:100])[0:100]+"...\n" + "\033[0m")
+ results += str(content)+". "
+
+
+ return results
+
+
+def simplify_search_results(search_results):
+ simplified_results = []
+ for result in search_results:
+ simplified_result = {
+ "position": result.get("position"),
+ "title": result.get("title"),
+ "link": result.get("link"),
+ "snippet": result.get("snippet")
+ }
+ simplified_results.append(simplified_result)
+ return simplified_results
+
+
+def web_scrape_tool(url: str, task:str):
+ content = fetch_url_content(url)
+ if content is None:
+ return None
+
+ text = extract_text(content)
+ print("\033[90m\033[3m"+"Scrape completed. Length:" +str(len(text))+".Now extracting relevant info..."+"...\033[0m")
+ info = extract_relevant_info(OBJECTIVE, text[0:5000], task)
+ links = extract_links(content)
+
+ #result = f"{info} URLs: {', '.join(links)}"
+ result = info
+
+ return result
+
+headers = {
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36"
+}
+
+def fetch_url_content(url: str):
+ try:
+ response = requests.get(url, headers=headers, timeout=10)
+ response.raise_for_status()
+ return response.content
+ except requests.exceptions.RequestException as e:
+ print(f"Error while fetching the URL: {e}")
+ return ""
+
+def extract_links(content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ links = [link.get('href') for link in soup.findAll('a', attrs={'href': re.compile("^https?://")})]
+ return links
+
+def extract_text(content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ text = soup.get_text(strip=True)
+ return text
+
+
+
+def extract_relevant_info(objective, large_string, task):
+ chunk_size = 3000
+ overlap = 500
+ notes = ""
+
+ for i in range(0, len(large_string), chunk_size - overlap):
+ chunk = large_string[i:i + chunk_size]
+
+ messages = [
+ {"role": "system", "content": f"Objective: {objective}\nCurrent Task:{task}"},
+ {"role": "user", "content": f"Analyze the following text and extract information relevant to our objective and current task, and only information relevant to our objective and current task. If there is no relevant information do not say that there is no relevant informaiton related to our objective. ### Then, update or start our notes provided here (keep blank if currently blank): {notes}.### Text to analyze: {chunk}.### Updated Notes:"}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ max_tokens=800,
+ n=1,
+ stop="###",
+ temperature=0.7,
+ )
+
+ notes += response.choices[0].message['content'].strip()+". ";
+
+ return notes
+
+### Agent functions ##############################
+
+
+def execute_task(task, task_list, OBJECTIVE):
+ global task_id_counter
+ # Check if dependent_task_ids is not empty
+ if task["dependent_task_ids"]:
+ all_dependent_tasks_complete = True
+ for dep_id in task["dependent_task_ids"]:
+ dependent_task = get_task_by_id(dep_id)
+ if not dependent_task or dependent_task["status"] != "complete":
+ all_dependent_tasks_complete = False
+ break
+
+
+ # Execute task
+ print("\033[92m\033[1m"+"\n*****NEXT TASK*****\n"+"\033[0m\033[0m")
+ print(str(task['id'])+": "+str(task['task'])+" ["+str(task['tool']+"]"))
+ task_prompt = f"Complete your assigned task based on the objective and only based on information provided in the dependent task output, if provided. Your objective: {OBJECTIVE}. Your task: {task['task']}"
+ if task["dependent_task_ids"]:
+ dependent_tasks_output = ""
+ for dep_id in task["dependent_task_ids"]:
+ dependent_task_output = get_task_by_id(dep_id)["output"]
+ dependent_task_output = dependent_task_output[0:2000]
+ dependent_tasks_output += f" {dependent_task_output}"
+ task_prompt += f" Your dependent tasks output: {dependent_tasks_output}\n OUTPUT:"
+
+ # Use tool to complete the task
+ if task["tool"] == "text-completion":
+ task_output = text_completion_tool(task_prompt)
+ elif task["tool"] == "web-search":
+ task_output = web_search_tool(str(task['task']))
+ elif task["tool"] == "web-scrape":
+ task_output = web_scrape_tool(str(task['task']))
+
+ # Find task index in the task_list
+ task_index = next((i for i, t in enumerate(task_list) if t["id"] == task["id"]), None)
+
+ # Mark task as complete and save output
+ task_list[task_index]["status"] = "complete"
+ task_list[task_index]["output"] = task_output
+
+ # Print task output
+ print("\033[93m\033[1m"+"\nTask Output:"+"\033[0m\033[0m")
+ print(task_output)
+
+ # Add task output to session_summary
+ global session_summary
+ session_summary += f"\n\nTask {task['id']} - {task['task']}:\n{task_output}"
+
+
+
+task_list = []
+
+def task_creation_agent(objective: str) -> List[Dict]:
+ global task_list
+ minified_task_list = [{k: v for k, v in task.items() if k != "result"} for task in task_list]
+
+ prompt = (
+ f"You are a task creation AI tasked with creating a list of tasks as a JSON array, considering the ultimate objective of your team: {OBJECTIVE}. "
+ f"Create new tasks based on the objective. Limit tasks types to those that can be completed with the available tools listed below. Task description should be detailed."
+ f"Current tool option is [text-completion] {websearch_var} and only." # web-search is added automatically if SERPAPI exists
+ f"For tasks using [web-search], provide the search query, and only the search query to use (eg. not 'research waterproof shoes, but 'waterproof shoes')"
+ f"dependent_task_ids should always be an empty array, or an array of numbers representing the task ID it should pull results from."
+ f"Make sure all task IDs are in chronological order.\n"
+ f"The last step is always to provide a final summary report including tasks executed and summary of knowledge acquired.\n"
+ f"Do not create any summarizing steps outside of the last step..\n"
+ f"An example of the desired output format is: "
+ "[{\"id\": 1, \"task\": \"https://untapped.vc\", \"tool\": \"web-scrape\", \"dependent_task_ids\": [], \"status\": \"incomplete\", \"result\": null, \"result_summary\": null}, {\"id\": 2, \"task\": \"Consider additional insights that can be reasoned from the results of...\", \"tool\": \"text-completion\", \"dependent_task_ids\": [1], \"status\": \"incomplete\", \"result\": null, \"result_summary\": null}, {\"id\": 3, \"task\": \"Untapped Capital\", \"tool\": \"web-search\", \"dependent_task_ids\": [], \"status\": \"incomplete\", \"result\": null, \"result_summary\": null}].\n"
+ f"JSON TASK LIST="
+ )
+
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ print("\033[90m\033[3m" + "Analyzing objective...\n" + "\033[0m")
+ print("\033[90m\033[3m" + "Running task creation agent...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-4",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print("\033[90m\033[3m" + "\nDone!\n" + "\033[0m")
+ try:
+ task_list = json.loads(result)
+ except Exception as error:
+ print(error)
+
+ return task_list
+
+##### START MAIN LOOP########
+
+#Print OBJECTIVE
+print("\033[96m\033[1m"+"\n*****OBJECTIVE*****\n"+"\033[0m\033[0m")
+print(OBJECTIVE)
+
+# Initialize task_id_counter
+task_id_counter = 1
+
+# Run the task_creation_agent to create initial tasks
+task_list = task_creation_agent(OBJECTIVE)
+print_tasklist()
+
+# Execute tasks in order
+while len(task_list) > 0:
+ for task in task_list:
+ if task["status"] == "incomplete":
+ execute_task(task, task_list, OBJECTIVE)
+ print_tasklist()
+ break
+
+# Print session summary
+print("\033[96m\033[1m"+"\n*****SESSION SUMMARY*****\n"+"\033[0m\033[0m")
+print(session_summary)
diff --git a/classic/BabyDeerAGI.py b/classic/BabyDeerAGI.py
new file mode 100644
index 00000000..5de33555
--- /dev/null
+++ b/classic/BabyDeerAGI.py
@@ -0,0 +1,354 @@
+###### This is a modified version of OG BabyAGI, called BabyDeerAGI (modifications will follow the pattern "BabyAGI").######
+######IMPORTANT NOTE: I'm sharing this as a framework to build on top of (with lots of room for improvement), to facilitate discussion around how to improve these. This is NOT for people who are looking for a complete solution that's ready to use. ######
+
+import openai
+import time
+from datetime import datetime
+import requests
+from bs4 import BeautifulSoup
+from collections import deque
+from typing import Dict, List
+import re
+import ast
+import json
+from serpapi import GoogleSearch
+from concurrent.futures import ThreadPoolExecutor
+import time
+
+### SET THESE 4 VARIABLES ##############################
+
+# Add your API keys here
+OPENAI_API_KEY = ""
+SERPAPI_API_KEY = "" #[optional] web-search becomes available automatically when serpapi api key is provided
+
+# Set variables
+OBJECTIVE = "Research recent AI news and write a poem about your findings in the style of shakespeare."
+
+#turn on user input (change to "True" to turn on user input tool)
+user_input=False
+
+### UP TO HERE ##############################
+
+# Configure OpenAI and SerpAPI client
+openai.api_key = OPENAI_API_KEY
+if SERPAPI_API_KEY:
+ serpapi_client = GoogleSearch({"api_key": SERPAPI_API_KEY})
+ websearch_var = "[web-search] "
+else:
+ websearch_var = ""
+
+if user_input == True:
+ user_input_var = "[user-input]"
+else:
+ user_input_var = ""
+
+
+# Initialize task list
+task_list = []
+
+# Initialize session_summary
+session_summary = "OBJECTIVE: "+OBJECTIVE+"\n\n"
+
+### Task list functions ##############################
+def get_task_by_id(task_id: int):
+ for task in task_list:
+ if task["id"] == task_id:
+ return task
+ return None
+
+# Print task list and session summary
+def print_tasklist():
+ p_tasklist="\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m"
+ for t in task_list:
+ dependent_task = ""
+ if t['dependent_task_ids']:
+ dependent_task = f"\033[31m\033[0m"
+ status_color = "\033[32m" if t['status'] == "complete" else "\033[31m"
+ p_tasklist+= f"\033[1m{t['id']}\033[0m: {t['task']} {status_color}[{t['status']}]\033[0m \033[93m[{t['tool']}] {dependent_task}\033[0m\n"
+ print(p_tasklist)
+
+### Tool functions ##############################
+def text_completion_tool(prompt: str):
+ messages = [
+ {"role": "user", "content": prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.2,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+def user_input_tool(prompt: str):
+ val = input(f"\n{prompt}\nYour response: ")
+ return str(val)
+
+
+def web_search_tool(query: str , dependent_tasks_output : str):
+
+ if dependent_tasks_output != "":
+ dependent_task = f"Use the dependent task output below as reference to help craft the correct search query for the provided task above. Dependent task output:{dependent_tasks_output}."
+ else:
+ dependent_task = "."
+ query = text_completion_tool("You are an AI assistant tasked with generating a Google search query based on the following task: "+query+". If the task looks like a search query, return the identical search query as your response. " + dependent_task + "\nSearch Query:")
+ print("\033[90m\033[3m"+"Search query: " +str(query)+"\033[0m")
+ search_params = {
+ "engine": "google",
+ "q": query,
+ "api_key": SERPAPI_API_KEY,
+ "num":3 #edit this up or down for more results, though higher often results in OpenAI rate limits
+ }
+ search_results = GoogleSearch(search_params)
+ search_results = search_results.get_dict()
+ try:
+ search_results = search_results["organic_results"]
+ except:
+ search_results = {}
+ search_results = simplify_search_results(search_results)
+ print("\033[90m\033[3m" + "Completed search. Now scraping results.\n" + "\033[0m")
+ results = "";
+ # Loop through the search results
+ for result in search_results:
+ # Extract the URL from the result
+ url = result.get('link')
+ # Call the web_scrape_tool function with the URL
+ print("\033[90m\033[3m" + "Scraping: "+url+"" + "...\033[0m")
+ content = web_scrape_tool(url, task)
+ print("\033[90m\033[3m" +str(content[0:100])[0:100]+"...\n" + "\033[0m")
+ results += str(content)+". "
+
+ results = text_completion_tool(f"You are an expert analyst. Rewrite the following information as one report without removing any facts.\n###INFORMATION:{results}.\n###REPORT:")
+ return results
+
+
+def simplify_search_results(search_results):
+ simplified_results = []
+ for result in search_results:
+ simplified_result = {
+ "position": result.get("position"),
+ "title": result.get("title"),
+ "link": result.get("link"),
+ "snippet": result.get("snippet")
+ }
+ simplified_results.append(simplified_result)
+ return simplified_results
+
+
+def web_scrape_tool(url: str, task:str):
+ content = fetch_url_content(url)
+ if content is None:
+ return None
+
+ text = extract_text(content)
+ print("\033[90m\033[3m"+"Scrape completed. Length:" +str(len(text))+".Now extracting relevant info..."+"...\033[0m")
+ info = extract_relevant_info(OBJECTIVE, text[0:5000], task)
+ links = extract_links(content)
+
+ #result = f"{info} URLs: {', '.join(links)}"
+ result = info
+
+ return result
+
+headers = {
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36"
+}
+
+def fetch_url_content(url: str):
+ try:
+ response = requests.get(url, headers=headers, timeout=10)
+ response.raise_for_status()
+ return response.content
+ except requests.exceptions.RequestException as e:
+ print(f"Error while fetching the URL: {e}")
+ return ""
+
+def extract_links(content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ links = [link.get('href') for link in soup.findAll('a', attrs={'href': re.compile("^https?://")})]
+ return links
+
+def extract_text(content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ text = soup.get_text(strip=True)
+ return text
+
+
+
+def extract_relevant_info(objective, large_string, task):
+ chunk_size = 3000
+ overlap = 500
+ notes = ""
+
+ for i in range(0, len(large_string), chunk_size - overlap):
+ chunk = large_string[i:i + chunk_size]
+
+ messages = [
+ {"role": "system", "content": f"You are an AI assistant."},
+ {"role": "user", "content": f"You are an expert AI research assistant tasked with creating or updating the current notes. If the current note is empty, start a current-notes section by exracting relevant data to the task and objective from the chunk of text to analyze. If there is a current note, add new relevant info frol the chunk of text to analyze. Make sure the new or combined notes is comprehensive and well written. Here's the current chunk of text to analyze: {chunk}. ### Here is the current task: {task}.### For context, here is the objective: {OBJECTIVE}.### Here is the data we've extraced so far that you need to update: {notes}.### new-or-updated-note:"}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ max_tokens=800,
+ n=1,
+ stop="###",
+ temperature=0.7,
+ )
+
+ notes += response.choices[0].message['content'].strip()+". ";
+
+ return notes
+
+### Agent functions ##############################
+
+
+def execute_task(task, task_list, OBJECTIVE):
+
+ global session_summary
+ global task_id_counter
+ # Check if dependent_task_ids is not empty
+ if task["dependent_task_ids"]:
+ all_dependent_tasks_complete = True
+ for dep_id in task["dependent_task_ids"]:
+ dependent_task = get_task_by_id(dep_id)
+ if not dependent_task or dependent_task["status"] != "complete":
+ all_dependent_tasks_complete = False
+ break
+
+
+ # Execute task
+ p_nexttask="\033[92m\033[1m"+"\n*****NEXT TASK ID:"+str(task['id'])+"*****\n"+"\033[0m\033[0m"
+ p_nexttask += str(task['id'])+": "+str(task['task'])+" ["+str(task['tool']+"]")
+ print(p_nexttask)
+ task_prompt = f"Complete your assigned task based on the objective and only based on information provided in the dependent task output, if provided. \n###\nYour objective: {OBJECTIVE}. \n###\nYour task: {task['task']}"
+ if task["dependent_task_ids"]:
+ dependent_tasks_output = ""
+ for dep_id in task["dependent_task_ids"]:
+ dependent_task_output = get_task_by_id(dep_id)["output"]
+ dependent_task_output = dependent_task_output[0:2000]
+ dependent_tasks_output += f" {dependent_task_output}"
+ task_prompt += f" \n###\ndependent tasks output: {dependent_tasks_output} \n###\nYour task: {task['task']}\n###\nRESPONSE:"
+ else:
+ dependent_tasks_output="."
+
+ # Use tool to complete the task
+ if task["tool"] == "text-completion":
+ task_output = text_completion_tool(task_prompt)
+ elif task["tool"] == "web-search":
+ task_output = web_search_tool(str(task['task']),str(dependent_tasks_output))
+ elif task["tool"] == "web-scrape":
+ task_output = web_scrape_tool(str(task['task']))
+ elif task["tool"] == "user-input":
+ task_output = user_input_tool(str(task['task']))
+
+
+
+ # Find task index in the task_list
+ task_index = next((i for i, t in enumerate(task_list) if t["id"] == task["id"]), None)
+
+ # Mark task as complete and save output
+ task_list[task_index]["status"] = "complete"
+ task_list[task_index]["output"] = task_output
+
+ # Print task output
+ print("\033[93m\033[1m"+"\nTask Output (ID:"+str(task['id'])+"):"+"\033[0m\033[0m")
+ print(task_output)
+ # Add task output to session_summary
+ session_summary += f"\n\nTask {task['id']} - {task['task']}:\n{task_output}"
+
+def task_ready_to_run(task, task_list):
+ return all([get_task_by_id(dep_id)["status"] == "complete" for dep_id in task["dependent_task_ids"]])
+
+
+task_list = []
+
+def task_creation_agent(objective: str) -> List[Dict]:
+ global task_list
+ minified_task_list = [{k: v for k, v in task.items() if k != "result"} for task in task_list]
+
+ prompt = (
+ f"You are an expert task creation AI tasked with creating a list of tasks as a JSON array, considering the ultimate objective of your team: {OBJECTIVE}. "
+ f"Create new tasks based on the objective. Limit tasks types to those that can be completed with the available tools listed below. Task description should be detailed."
+ f"Current tool options are [text-completion] {websearch_var} {user_input_var}." # web-search is added automatically if SERPAPI exists
+ f"For tasks using [web-search], provide the search query, and only the search query to use (eg. not 'research waterproof shoes, but 'waterproof shoes'). Result will be a summary of relevant information from the first few articles."
+ f"When requiring multiple searches, use the [web-search] multiple times. This tool will use the dependent task result to generate the search query if necessary."
+ f"Use [user-input] sparingly and only if you need to ask a question to the user who set up the objective. The task description should be the question you want to ask the user.')"
+ f"dependent_task_ids should always be an empty array, or an array of numbers representing the task ID it should pull results from."
+ f"Make sure all task IDs are in chronological order.\n"
+ f"EXAMPLE OBJECTIVE=Look up AI news from today (May 27, 2023) and write a poem."
+ "TASK LIST=[{\"id\":1,\"task\":\"AI news today\",\"tool\":\"web-search\",\"dependent_task_ids\":[],\"status\":\"incomplete\",\"result\":null,\"result_summary\":null},{\"id\":2,\"task\":\"Extract key points from AI news articles\",\"tool\":\"text-completion\",\"dependent_task_ids\":[1],\"status\":\"incomplete\",\"result\":null,\"result_summary\":null},{\"id\":3,\"task\":\"Generate a list of AI-related words and phrases\",\"tool\":\"text-completion\",\"dependent_task_ids\":[2],\"status\":\"incomplete\",\"result\":null,\"result_summary\":null},{\"id\":4,\"task\":\"Write a poem using AI-related words and phrases\",\"tool\":\"text-completion\",\"dependent_task_ids\":[3],\"status\":\"incomplete\",\"result\":null,\"result_summary\":null},{\"id\":5,\"task\":\"Final summary report\",\"tool\":\"text-completion\",\"dependent_task_ids\":[1,2,3,4],\"status\":\"incomplete\",\"result\":null,\"result_summary\":null}]"
+ f"OBJECTIVE={OBJECTIVE}"
+ f"TASK LIST="
+ )
+
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ task_list = json.loads(result)
+ except Exception as error:
+ print(error)
+
+ return task_list
+
+##### START MAIN LOOP########
+
+#Print OBJECTIVE
+print("\033[96m\033[1m"+"\n*****OBJECTIVE*****\n"+"\033[0m\033[0m")
+print(OBJECTIVE)
+
+# Initialize task_id_counter
+task_id_counter = 1
+
+# Run the task_creation_agent to create initial tasks
+task_list = task_creation_agent(OBJECTIVE)
+print_tasklist()
+
+# Create a ThreadPoolExecutor
+with ThreadPoolExecutor() as executor:
+ while True:
+ tasks_submitted = False
+ for task in task_list:
+ if task["status"] == "incomplete" and task_ready_to_run(task, task_list):
+ future = executor.submit(execute_task, task, task_list, OBJECTIVE)
+ task["status"] = "running"
+ tasks_submitted = True
+
+ if not tasks_submitted and all(task["status"] == "complete" for task in task_list):
+ break
+
+ time.sleep(5)
+
+# Print session summary
+print("\033[96m\033[1m"+"\n*****SAVING FILE...*****\n"+"\033[0m\033[0m")
+file = open(f'output/output_{datetime.now().strftime("%d_%m_%Y_%H_%M_%S")}.txt', 'w')
+file.write(session_summary)
+file.close()
+print("...file saved.")
+print("END")
diff --git a/classic/BabyElfAGI/main.py b/classic/BabyElfAGI/main.py
new file mode 100644
index 00000000..452c58e5
--- /dev/null
+++ b/classic/BabyElfAGI/main.py
@@ -0,0 +1,118 @@
+import os
+from dotenv import load_dotenv
+import importlib.util
+import json
+import openai
+import concurrent.futures
+import time
+from datetime import datetime
+from skills.skill import Skill
+from skills.skill_registry import SkillRegistry
+from tasks.task_registry import TaskRegistry
+
+
+load_dotenv() # Load environment variables from .env file
+
+# Retrieve all API keys
+api_keys = {
+ 'openai': os.environ['OPENAI_API_KEY'],
+ 'serpapi': os.environ['SERPAPI_API_KEY']
+ # Add more keys here as needed
+}
+
+# Set OBJECTIVE
+OBJECTIVE = "Create an example objective and tasklist for 'write a poem', which only uses text_completion in the tasks. Do this by usign code_reader to read example1.json, then writing the JSON objective tasklist pair using text_completion, and saving it using objective_saver."
+LOAD_SKILLS = ['text_completion','code_reader','objective_saver']
+REFLECTION = False
+
+##### START MAIN LOOP########
+
+# Print OBJECTIVE
+print("\033[96m\033[1m"+"\n*****OBJECTIVE*****\n"+"\033[0m\033[0m")
+print(OBJECTIVE)
+
+if __name__ == "__main__":
+ session_summary = ""
+
+ # Initialize the SkillRegistry and TaskRegistry
+ skill_registry = SkillRegistry(api_keys=api_keys, skill_names=LOAD_SKILLS)
+ skill_descriptions = ",".join(f"[{skill.name}: {skill.description}]" for skill in skill_registry.skills.values())
+ task_registry = TaskRegistry()
+
+ # Create the initial task list based on an objective
+ task_registry.create_tasklist(OBJECTIVE, skill_descriptions)
+
+ # Initialize task outputs
+ task_outputs = {i: {"completed": False, "output": None} for i, _ in enumerate(task_registry.get_tasks())}
+
+ # Create a thread pool for parallel execution
+ with concurrent.futures.ThreadPoolExecutor() as executor:
+ # Loop until all tasks are completed
+ while not all(task["completed"] for task in task_outputs.values()):
+
+ # Get the tasks that are ready to be executed (i.e., all their dependencies have been completed)
+ tasks = task_registry.get_tasks()
+ # Print the updated task list
+ task_registry.print_tasklist(tasks)
+
+ # Update task_outputs to include new tasks
+ for task in tasks:
+ if task["id"] not in task_outputs:
+ task_outputs[task["id"]] = {"completed": False, "output": None}
+
+
+ ready_tasks = [(task["id"], task) for task in tasks
+ if all((dep in task_outputs and task_outputs[dep]["completed"])
+ for dep in task.get('dependent_task_ids', []))
+ and not task_outputs[task["id"]]["completed"]]
+
+ session_summary += str(task)+"\n"
+ futures = [executor.submit(task_registry.execute_task, task_id, task, skill_registry, task_outputs, OBJECTIVE)
+ for task_id, task in ready_tasks if not task_outputs[task_id]["completed"]]
+
+ # Wait for the tasks to complete
+ for future in futures:
+ i, output = future.result()
+ task_outputs[i]["output"] = output
+ task_outputs[i]["completed"] = True
+
+ # Update the task in the TaskRegistry
+ task_registry.update_tasks({"id": i, "status": "completed", "result": output})
+
+ completed_task = task_registry.get_task(i)
+ print(f"\033[92mTask #{i}: {completed_task.get('task')} \033[0m\033[92m[COMPLETED]\033[0m\033[92m[{completed_task.get('skill')}]\033[0m")
+
+ # Reflect on the output
+ if output:
+ session_summary += str(output)+"\n"
+
+
+ if REFLECTION == True:
+ new_tasks, insert_after_ids, tasks_to_update = task_registry.reflect_on_output(output, skill_descriptions)
+ # Insert new tasks
+ for new_task, after_id in zip(new_tasks, insert_after_ids):
+ task_registry.add_task(new_task, after_id)
+
+ # Update existing tasks
+ for task_to_update in tasks_to_update:
+ task_registry.update_tasks(task_to_update)
+
+
+
+ #print(task_outputs.values())
+ if all(task["status"] == "completed" for task in task_registry.tasks):
+ print("All tasks completed!")
+ break
+
+ # Short delay to prevent busy looping
+ time.sleep(0.1)
+
+
+ # Print session summary
+ print("\033[96m\033[1m"+"\n*****SAVING FILE...*****\n"+"\033[0m\033[0m")
+ file = open(f'output/output_{datetime.now().strftime("%d_%m_%Y_%H_%M_%S")}.txt', 'w')
+ file.write(session_summary)
+ file.close()
+ print("...file saved.")
+ print("END")
+ executor.shutdown()
\ No newline at end of file
diff --git a/classic/BabyElfAGI/skills/code_reader.py b/classic/BabyElfAGI/skills/code_reader.py
new file mode 100644
index 00000000..11660eea
--- /dev/null
+++ b/classic/BabyElfAGI/skills/code_reader.py
@@ -0,0 +1,79 @@
+from skills.skill import Skill
+import openai
+import os
+
+class CodeReader(Skill):
+ name = 'code_reader'
+ description = "A skill that finds a file's location in it's own program's directory and returns its contents."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys):
+ super().__init__(api_keys)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ dir_structure = self.get_directory_structure(self.get_top_parent_path(os.path.realpath(__file__)))
+ print(f"Directory structure: {dir_structure}")
+ example_dir_structure = {'.': {'main.py': None}, 'skills': {'__init__.py': None, 'web_scrape.py': None, 'skill.py': None, 'test_skill.py': None, 'text_completion.py': None, 'web_search.py': None, 'skill_registry.py': None, 'directory_structure.py': None, 'code_reader.py': None}, 'tasks': {'task_registry.py': None}, 'output': {}}
+ example_params = "Analyze main.py"
+ example_response = "main.py"
+
+ task_prompt = f"Find a specific file in a directory and return only the file path, based on the task description below. Always return a directory.###The directory structure is as follows: \n{example_dir_structure}\nYour task: {example_params}\n###\nRESPONSE:{example_response} ###The directory structure is as follows: \n{dir_structure}\nYour task: {params}\n###\nRESPONSE:"
+
+ messages = [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.2,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+ file_path = response.choices[0].message['content'].strip()
+ print(f"AI suggested file path: {file_path}")
+
+ try:
+ with open(file_path, 'r') as file:
+ file_content = file.read()
+ print(f"File content:\n{file_content}")
+ return file_content
+ except FileNotFoundError:
+ print("File not found. Please check the AI's suggested file path.")
+ return None
+
+ def get_directory_structure(self, start_path):
+ dir_structure = {}
+ ignore_dirs = ['.','__init__.py', '__pycache__', 'pydevd', 'poetry','venv'] # add any other directories to ignore here
+
+ for root, dirs, files in os.walk(start_path):
+ dirs[:] = [d for d in dirs if not any(d.startswith(i) for i in ignore_dirs)] # exclude specified directories
+ files = [f for f in files if not f[0] == '.' and f.endswith('.py')] # exclude hidden files and non-Python files
+
+ current_dict = dir_structure
+ path_parts = os.path.relpath(root, start_path).split(os.sep)
+ for part in path_parts:
+ if part: # skip empty parts
+ if part not in current_dict:
+ current_dict[part] = {}
+ current_dict = current_dict[part]
+ for f in files:
+ current_dict[f] = None
+
+ return dir_structure
+
+ def get_top_parent_path(self, current_path):
+ relative_path = ""
+ while True:
+ new_path = os.path.dirname(current_path)
+ if new_path == '/home/runner/BabyElfAGI/skills': # reached the top
+ return '/home/runner/BabyElfAGI'
+ current_path = new_path
+ relative_path = os.path.join("..", relative_path)
+
+ return relative_path
diff --git a/classic/BabyElfAGI/skills/directory_structure.py b/classic/BabyElfAGI/skills/directory_structure.py
new file mode 100644
index 00000000..5b071167
--- /dev/null
+++ b/classic/BabyElfAGI/skills/directory_structure.py
@@ -0,0 +1,56 @@
+from skills.skill import Skill
+import os
+
+class DirectoryStructure(Skill):
+ name = 'directory_structure'
+ description = "A tool that outputs the file and folder structure of its top parent folder."
+
+ def __init__(self, api_keys=None):
+ super().__init__(api_keys)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ # Get the current script path
+ current_script_path = os.path.realpath(__file__)
+
+ # Get the top parent directory of current script
+ top_parent_path = self.get_top_parent_path(current_script_path)
+ # Get the directory structure from the top parent directory
+ dir_structure = self.get_directory_structure(top_parent_path)
+
+ return dir_structure
+
+ def get_directory_structure(self, start_path):
+ dir_structure = {}
+ ignore_dirs = ['.','__init__.py', '__pycache__', 'pydevd', 'poetry','venv'] # add any other directories to ignore here
+
+ for root, dirs, files in os.walk(start_path):
+ dirs[:] = [d for d in dirs if not any(d.startswith(i) for i in ignore_dirs)] # exclude specified directories
+ files = [f for f in files if not f[0] == '.' and f.endswith('.py')] # exclude hidden files and non-Python files
+
+ current_dict = dir_structure
+ path_parts = os.path.relpath(root, start_path).split(os.sep)
+ for part in path_parts:
+ if part: # skip empty parts
+ if part not in current_dict:
+ current_dict[part] = {}
+ current_dict = current_dict[part]
+ for f in files:
+ current_dict[f] = None
+ #print("#############################")
+ #print(str(current_dict)[0:100])
+ return dir_structure
+
+
+
+ def get_top_parent_path(self, current_path):
+ relative_path = ""
+ while True:
+ new_path = os.path.dirname(current_path)
+ print(new_path)
+ if new_path == '/home/runner/BabyElfAGI/skills': # reached the top
+ #if new_path == current_path: # reached the top
+ #return relative_path
+ return '/home/runner/BabyElfAGI'
+ current_path = new_path
+ relative_path = os.path.join("..", relative_path)
+ print(relative_path)
\ No newline at end of file
diff --git a/classic/BabyElfAGI/skills/objective_saver.py b/classic/BabyElfAGI/skills/objective_saver.py
new file mode 100644
index 00000000..0c74f8fe
--- /dev/null
+++ b/classic/BabyElfAGI/skills/objective_saver.py
@@ -0,0 +1,43 @@
+from skills.skill import Skill
+import os
+import openai
+
+class ObjectiveSaver(Skill):
+ name = 'objective_saver'
+ description = "A skill that saves a new example_objective based on the concepts from skill_saver.py"
+ api_keys_required = []
+
+ def __init__(self, api_keys):
+ super().__init__(api_keys)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+ #print(dependent_task_outputs[2])
+ code = dependent_task_outputs[2]
+ task_prompt = f"Come up with a file name (eg. 'research_shoes.json') for the following objective:{code}\n###\nFILE_NAME:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ file_name = response.choices[0].message['content'].strip()
+ file_path = os.path.join('tasks/example_objectives',file_name)
+
+ try:
+ with open(file_path, 'w') as file:
+ file.write("["+code+"]")
+ print(f"Code saved successfully: {file_name}")
+ except:
+ print("Error saving code.")
+
+ return None
\ No newline at end of file
diff --git a/classic/BabyElfAGI/skills/skill.py b/classic/BabyElfAGI/skills/skill.py
new file mode 100644
index 00000000..5875b656
--- /dev/null
+++ b/classic/BabyElfAGI/skills/skill.py
@@ -0,0 +1,33 @@
+class Skill:
+ name = 'base skill'
+ description = 'This is the base skill.'
+ api_keys_required = []
+
+ def __init__(self, api_keys):
+ self.api_keys = api_keys
+ missing_keys = self.check_required_keys(api_keys)
+ if missing_keys:
+ print(f"Missing API keys for {self.name}: {missing_keys}")
+ self.valid = False
+ else:
+ self.valid = True
+ for key in self.api_keys_required:
+ if isinstance(key, list):
+ for subkey in key:
+ if subkey in api_keys:
+ setattr(self, f"{subkey}_api_key", api_keys.get(subkey))
+ elif key in api_keys:
+ setattr(self, f"{key}_api_key", api_keys.get(key))
+
+ def check_required_keys(self, api_keys):
+ missing_keys = []
+ for key in self.api_keys_required:
+ if isinstance(key, list): # If the key is actually a list of alternatives
+ if not any(k in api_keys for k in key): # If none of the alternatives are present
+ missing_keys.append(key) # Add the list of alternatives to the missing keys
+ elif key not in api_keys: # If the key is a single key and it's not present
+ missing_keys.append(key) # Add the key to the missing keys
+ return missing_keys
+
+ def execute(self, params, dependent_task_outputs, objective):
+ raise NotImplementedError('Execute method must be implemented in subclass.')
\ No newline at end of file
diff --git a/classic/BabyElfAGI/skills/skill_registry.py b/classic/BabyElfAGI/skills/skill_registry.py
new file mode 100644
index 00000000..0f06486d
--- /dev/null
+++ b/classic/BabyElfAGI/skills/skill_registry.py
@@ -0,0 +1,57 @@
+import os
+import importlib.util
+import inspect
+from .skill import Skill
+
+class SkillRegistry:
+ def __init__(self, api_keys, skill_names=None):
+ self.skills = {}
+ skill_files = [f for f in os.listdir('skills') if f.endswith('.py') and f != 'skill.py']
+ for skill_file in skill_files:
+ module_name = skill_file[:-3]
+ if skill_names and module_name not in skill_names:
+ continue
+ module = importlib.import_module(f'skills.{module_name}')
+ for attr_name in dir(module):
+ attr_value = getattr(module, attr_name)
+ if inspect.isclass(attr_value) and issubclass(attr_value, Skill) and attr_value is not Skill:
+ skill = attr_value(api_keys)
+ if skill.valid:
+ self.skills[skill.name] = skill
+ # Print the names and descriptions of all loaded skills
+ skill_info = "\n".join([f"{skill_name}: {skill.description}" for skill_name, skill in self.skills.items()])
+ # print(skill_info)
+
+ def load_all_skills(self):
+ skills_dir = os.path.dirname(__file__)
+ for filename in os.listdir(skills_dir):
+ if filename.endswith(".py") and filename not in ["__init__.py", "skill.py", "skill_registry.py"]:
+ skill_name = filename[:-3] # Remove .py extension
+ self.load_skill(skill_name)
+
+ def load_specific_skills(self, skill_names):
+ for skill_name in skill_names:
+ self.load_skill(skill_name)
+
+ def load_skill(self, skill_name):
+ skills_dir = os.path.dirname(__file__)
+ filename = f"{skill_name}.py"
+ if os.path.isfile(os.path.join(skills_dir, filename)):
+ spec = importlib.util.spec_from_file_location(skill_name, os.path.join(skills_dir, filename))
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ for item_name in dir(module):
+ item = getattr(module, item_name)
+ if isinstance(item, type) and issubclass(item, Skill) and item is not Skill:
+ skill_instance = item(self.api_keys)
+ self.skills[skill_instance.name] = skill_instance
+
+ def get_skill(self, skill_name):
+ skill = self.skills.get(skill_name)
+ if skill is None:
+ raise Exception(
+ f"Skill '{skill_name}' not found. Please make sure the skill is loaded and all required API keys are set.")
+ return skill
+
+ def get_all_skills(self):
+ return self.skills
\ No newline at end of file
diff --git a/classic/BabyElfAGI/skills/skill_saver.py b/classic/BabyElfAGI/skills/skill_saver.py
new file mode 100644
index 00000000..99be35c7
--- /dev/null
+++ b/classic/BabyElfAGI/skills/skill_saver.py
@@ -0,0 +1,58 @@
+from skills.skill import Skill
+import os
+import openai
+
+class SkillSaver(Skill):
+ name = 'skill_saver'
+ description = "A skill that saves code written in a previous step into a file within the skills folder. Not for writing code."
+ api_keys_required = []
+
+ def __init__(self, api_keys):
+ super().__init__(api_keys)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ task_prompt = f"Extract the code and only the code from the dependent task output here: {dependent_task_outputs} \n###\nCODE:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ code = response.choices[0].message['content'].strip()
+ task_prompt = f"Come up with a file name (eg. 'get_weather.py') for the following skill:{code}\n###\nFILE_NAME:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ file_name = response.choices[0].message['content'].strip()
+ file_path = os.path.join('skills',file_name)
+
+ try:
+ with open(file_path, 'w') as file:
+ file.write(code)
+ print(f"Code saved successfully: {file_name}")
+ except:
+ print("Error saving code.")
+
+ return None
\ No newline at end of file
diff --git a/classic/BabyElfAGI/skills/text_completion.py b/classic/BabyElfAGI/skills/text_completion.py
new file mode 100644
index 00000000..6abcd276
--- /dev/null
+++ b/classic/BabyElfAGI/skills/text_completion.py
@@ -0,0 +1,31 @@
+from skills.skill import Skill
+import openai
+
+class TextCompletion(Skill):
+ name = 'text_completion'
+ description = "A tool that uses OpenAI's text completion API to generate, summarize, and/or analyze text and code."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys):
+ super().__init__(api_keys)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ task_prompt = f"Complete your assigned task based on the objective and only based on information provided in the dependent task output, if provided. \n###\nYour objective: {objective}. \n###\nYour task: {params} \n###\nDependent tasks output: {dependent_task_outputs} \n###\nYour task: {params}\n###\nRESPONSE:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=2000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return "\n\n"+response.choices[0].message['content'].strip()
diff --git a/classic/BabyElfAGI/skills/web_search.py b/classic/BabyElfAGI/skills/web_search.py
new file mode 100644
index 00000000..ec4a2c14
--- /dev/null
+++ b/classic/BabyElfAGI/skills/web_search.py
@@ -0,0 +1,151 @@
+
+from skills.skill import Skill
+from serpapi import GoogleSearch
+import openai
+from bs4 import BeautifulSoup
+import requests
+import re
+
+headers = {
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36"
+}
+
+class WebSearch(Skill):
+ name = 'web_search'
+ description = 'A tool that performs web searches.'
+ api_keys_required = [['openai'],['serpapi']]
+
+ def __init__(self, api_keys):
+ super().__init__(api_keys)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ # Your function goes here
+
+
+ # Modify the query based on the dependent task output
+ if dependent_task_outputs != "":
+ dependent_task = f"Use the dependent task output below as reference to help craft the correct search query for the provided task above. Dependent task output:{dependent_task_outputs}."
+ else:
+ dependent_task = "."
+ query = self.text_completion_tool("You are an AI assistant tasked with generating a Google search query based on the following task: "+params+". If the task looks like a search query, return the identical search query as your response. " + dependent_task + "\nSearch Query:")
+ print("\033[90m\033[3m"+"Search query: " +str(query)+"\033[0m")
+ # Set the search parameters
+ search_params = {
+ "engine": "google",
+ "q": query,
+ "api_key": self.serpapi_api_key,
+ "num": 3
+ }
+ # Perform the web search
+ search_results = GoogleSearch(search_params).get_dict()
+
+ # Simplify the search results
+ search_results = self.simplify_search_results(search_results.get('organic_results', []))
+ print("\033[90m\033[3mCompleted search. Now scraping results.\n\033[0m")
+
+ # Store the results from web scraping
+ results = ""
+ for result in search_results:
+ url = result.get('link')
+ print("\033[90m\033[3m" + "Scraping: "+url+"" + "...\033[0m")
+ content = self.web_scrape_tool({"url": url, "task": params,"objective":objective})
+ results += str(content) + ". "
+ print("\033[90m\033[3m"+str(results[0:100])[0:100]+"...\033[0m")
+ # Process the results and generate a report
+ results = self.text_completion_tool(f"You are an expert analyst combining the results of multiple web scrapes. Rewrite the following information as one cohesive report without removing any facts. Ignore any reports of not having info, unless all reports say so - in which case explain that the search did not work and suggest other web search queries to try. \n###INFORMATION:{results}.\n###REPORT:")
+ return results
+
+ def simplify_search_results(self, search_results):
+ simplified_results = []
+ for result in search_results:
+ simplified_result = {
+ "position": result.get("position"),
+ "title": result.get("title"),
+ "link": result.get("link"),
+ "snippet": result.get("snippet")
+ }
+ simplified_results.append(simplified_result)
+ return simplified_results
+
+
+ def text_completion_tool(self, prompt: str):
+ messages = [
+ {"role": "user", "content": prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k-0613",
+ messages=messages,
+ temperature=0.2,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+ def web_scrape_tool(self, params):
+ content = self.fetch_url_content(params['url'])
+ if content is None:
+ return None
+
+ text = self.extract_text(content)
+ print("\033[90m\033[3m"+"Scrape completed. Length:" +str(len(text))+".Now extracting relevant info..."+"...\033[0m")
+ info = self.extract_relevant_info(params['objective'], text[0:11000], params['task'])
+ links = self.extract_links(content)
+ #result = f"{info} URLs: {', '.join(links)}"
+ result = info
+
+ return result
+
+ def fetch_url_content(self,url: str):
+ try:
+ response = requests.get(url, headers=headers, timeout=10)
+ response.raise_for_status()
+ return response.content
+ except requests.exceptions.RequestException as e:
+ print(f"Error while fetching the URL: {e}")
+ return ""
+
+ def extract_links(self,content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ links = [link.get('href') for link in soup.findAll('a', attrs={'href': re.compile("^https?://")})]
+ return links
+
+ def extract_text(self,content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ text = soup.get_text(strip=True)
+ return text
+
+ def extract_relevant_info(self, objective, large_string, task):
+ chunk_size = 12000
+ overlap = 500
+ notes = ""
+
+ if len(large_string) == 0:
+ print("error scraping")
+ return "Error scraping."
+
+ for i in range(0, len(large_string), chunk_size - overlap):
+
+ print("\033[90m\033[3m"+"Reading chunk..."+"\033[0m")
+ chunk = large_string[i:i + chunk_size]
+
+ messages = [
+ {"role": "system", "content": f"You are an AI assistant."},
+ {"role": "user", "content": f"You are an expert AI research assistant tasked with creating or updating the current notes. If the current note is empty, start a current-notes section by exracting relevant data to the task and objective from the chunk of text to analyze. If there is a current note, add new relevant info frol the chunk of text to analyze. Make sure the new or combined notes is comprehensive and well written. Here's the current chunk of text to analyze: {chunk}. ### Here is the current task: {task}.### For context, here is the objective: {objective}.### Here is the data we've extraced so far that you need to update: {notes}.### new-or-updated-note:"}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k-0613",
+ messages=messages,
+ max_tokens=800,
+ n=1,
+ stop="###",
+ temperature=0.7,
+ )
+
+ notes += response.choices[0].message['content'].strip()+". ";
+
+ return notes
\ No newline at end of file
diff --git a/classic/BabyElfAGI/tasks/example_objectives/example1.json b/classic/BabyElfAGI/tasks/example_objectives/example1.json
new file mode 100644
index 00000000..64a39aa5
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/example_objectives/example1.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Create a new skill that writes a poem based on an input.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Read the code in text_completion.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a new skill that uses the concepts from text_completion.py to generate a poem based on user input.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created skill using the skill_saver skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/BabyElfAGI/tasks/example_objectives/example2.json b/classic/BabyElfAGI/tasks/example_objectives/example2.json
new file mode 100644
index 00000000..a9b93d67
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/example_objectives/example2.json
@@ -0,0 +1,33 @@
+[{
+ "objective": "Create a new skill that looks up the weather based on a location input.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Search code examples for free weather APIs to gather information on how to retrieve weather data based on a location input.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Read the code in text_completion.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Write a new skill that combines the concepts from text_completion.py and the code examples for free weather APIs to implement weather lookup based on a location input.",
+ "skill": "text_completion",
+ "dependent_task_ids": [2, 1],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Save the newly created skill using the skill_saver skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [3],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/BabyElfAGI/tasks/example_objectives/example3.json b/classic/BabyElfAGI/tasks/example_objectives/example3.json
new file mode 100644
index 00000000..9fdcfdb5
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/example_objectives/example3.json
@@ -0,0 +1,40 @@
+[{
+ "objective": "Research untapped.vc",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Conduct a web search on 'untapped.vc' to gather information about the company, its investments, and its impact in the startup ecosystem.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Based on the results from the first web search, perform a follow-up web search to explore specific areas of interest or investment strategies of 'untapped.vc'.",
+ "skill": "web_search",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Use text_completion to summarize the findings from the initial web search on 'untapped.vc' and provide key insights.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Use text_completion to summarize the findings from the follow-up web search and highlight any additional information or insights.",
+ "skill": "text_completion",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ },
+ {
+ "id": 5,
+ "task": "Combine the summaries from the initial and follow-up web searches to provide a comprehensive overview of 'untapped.vc' and its activities.",
+ "skill": "text_completion",
+ "dependent_task_ids": [3, 4],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/BabyElfAGI/tasks/example_objectives/example4.json b/classic/BabyElfAGI/tasks/example_objectives/example4.json
new file mode 100644
index 00000000..d7167763
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/example_objectives/example4.json
@@ -0,0 +1,54 @@
+[{
+ "objective": "Research Yohei Nakajima and Untapped Capital.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Conduct a web search on Yohei Nakajima.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Conduct a follow-up web search on Yohei Nakajima.",
+ "skill": "web_search",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Conduct a web search on Untapped Capital",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Conduct a follow-up web search on Untapped Capital",
+ "skill": "web_search",
+ "dependent_task_ids": [3],
+ "status": "incomplete"
+ },
+ {
+ "id": 5,
+ "task": "Analyze the findings from the web search on Yohei Nakajima and summarize his key contributions and areas of expertise.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1,2],
+ "status": "incomplete"
+ },
+ {
+ "id": 6,
+ "task": "Analyze the findings from the web search on Untapped Capital and summarize their investment strategies and notable portfolio companies.",
+ "skill": "text_completion",
+ "dependent_task_ids": [3,4],
+ "status": "incomplete"
+ },
+ {
+ "id": 7,
+ "task": "Combine the analyses of Yohei Nakajima and Untapped Capital to provide an overview of their collaboration or mutual interests.",
+ "skill": "text_completion",
+ "dependent_task_ids": [5, 6],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/BabyElfAGI/tasks/example_objectives/example5.json b/classic/BabyElfAGI/tasks/example_objectives/example5.json
new file mode 100644
index 00000000..ff779161
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/example_objectives/example5.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Based on skill_saver.py, write a new skill called objective_saver.py which saves a new example_objective.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Look up the code in skill_saver.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a new skill called objective_saver.py that saves a new example_objective based on the concepts from skill_saver.py (use text_completion).",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created example_objective using the skill_saver.py skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/BabyElfAGI/tasks/example_objectives/example6.json b/classic/BabyElfAGI/tasks/example_objectives/example6.json
new file mode 100644
index 00000000..855cd34d
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/example_objectives/example6.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Create new example objective for researching waterproof kid shoes.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Read the contents of example1.json in the example_objectives folder using the code_reader skill.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Use text_completion to generate a new example objective and task list as JSON based on the extracted information from example1.json.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created example objective and task list as JSON using the objective_saver skill.",
+ "skill": "objective_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/BabyElfAGI/tasks/task_registry.py b/classic/BabyElfAGI/tasks/task_registry.py
new file mode 100644
index 00000000..dba0f70a
--- /dev/null
+++ b/classic/BabyElfAGI/tasks/task_registry.py
@@ -0,0 +1,269 @@
+import openai
+import json
+import threading
+import os
+import numpy as np
+
+class TaskRegistry:
+ def __init__(self):
+ self.tasks = []
+ # Initialize the lock
+ self.lock = threading.Lock()
+ objectives_file_path = "tasks/example_objectives"
+ self.example_loader = ExampleObjectivesLoader(objectives_file_path)
+
+ def load_example_objectives(self, user_objective):
+ return self.example_loader.load_example_objectives(user_objective)
+
+
+ def create_tasklist(self, objective, skill_descriptions):
+ #load most relevant object and tasklist from objectives_examples.json
+ example_objective, example_tasklist = self.load_example_objectives(objective)
+
+ prompt = (
+ f"You are an expert task list creation AI tasked with creating a list of tasks as a JSON array, considering the ultimate objective of your team: {objective}. "
+ f"Create a very short task list based on the objective, the final output of the last task will be provided back to the user. Limit tasks types to those that can be completed with the available skills listed below. Task description should be detailed.###"
+ f"AVAILABLE SKILLS: {skill_descriptions}.###"
+ f"RULES:"
+ f"Do not use skills that are not listed."
+ f"Always include one skill."
+ f"dependent_task_ids should always be an empty array, or an array of numbers representing the task ID it should pull results from."
+ f"Make sure all task IDs are in chronological order.###\n"
+ f"EXAMPLE OBJECTIVE={json.dumps(example_objective)}"
+ f"TASK LIST={json.dumps(example_tasklist)}"
+ f"OBJECTIVE={objective}"
+ f"TASK LIST="
+ )
+
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-0613",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ task_list = json.loads(result)
+ self.tasks = task_list
+ except Exception as error:
+ print(error)
+
+
+ def execute_task(self, i, task, skill_registry, task_outputs, objective):
+ p_nexttask="\033[92m\033[1m"+"\n*****NEXT TASK ID:"+str(task['id'])+"*****\n"+"\033[0m\033[0m"
+ p_nexttask += f"\033[ EExecuting task {task.get('id')}: {task.get('task')}) [{task.get('skill')}]\033[)"
+ print(p_nexttask)
+ # Retrieve the skill from the registry
+ skill = skill_registry.get_skill(task['skill'])
+ # Get the outputs of the dependent tasks
+ dependent_task_outputs = {dep: task_outputs[dep]["output"] for dep in task['dependent_task_ids']} if 'dependent_task_ids' in task else {}
+ # Execute the skill
+ # print("execute:"+str([task['task'], dependent_task_outputs, objective]))
+ task_output = skill.execute(task['task'], dependent_task_outputs, objective)
+ print("\033[93m\033[1m"+"\nTask Output (ID:"+str(task['id'])+"):"+"\033[0m\033[0m")
+ print("TASK: "+str(task["task"]))
+ print("OUTPUT: "+str(task_output))
+ return i, task_output
+
+
+ def reorder_tasks(self):
+ self.tasks = sorted(self.tasks, key=lambda task: task['id'])
+
+
+ def add_task(self, task, after_task_id):
+ # Get the task ids
+ task_ids = [t["id"] for t in self.tasks]
+
+ # Get the index of the task id to add the new task after
+ insert_index = task_ids.index(after_task_id) + 1 if after_task_id in task_ids else len(task_ids)
+
+ # Insert the new task
+ self.tasks.insert(insert_index, task)
+ self.reorder_tasks()
+
+
+ def update_tasks(self, task_update):
+ for task in self.tasks:
+ if task['id'] == task_update['id']:
+ # This merges the original task dictionary with the update, overwriting only the fields present in the update.
+ task.update(task_update)
+ self.reorder_tasks()
+
+ def reflect_on_output(self, task_output, skill_descriptions):
+ with self.lock:
+ example = [
+ [
+ {"id": 3, "task": "New task 1 description", "skill": "text_completion_skill",
+ "dependent_task_ids": [], "status": "complete"},
+ {"id": 4, "task": "New task 2 description", "skill": "text_completion_skill",
+ "dependent_task_ids": [], "status": "incomplete"}
+ ],
+ [2, 3],
+ {"id": 5, "task": "Complete the objective and provide a final report",
+ "skill": "text_completion_skill", "dependent_task_ids": [1, 2, 3, 4], "status": "incomplete"}
+ ]
+
+ prompt = (
+ f"You are an expert task manager, review the task output to decide at least one new task to add."
+ f"As you add a new task, see if there are any tasks that need to be updated (such as updating dependencies)."
+ f"Use the current task list as reference."
+ f"Do not add duplicate tasks to those in the current task list."
+ f"Only provide JSON as your response without further comments."
+ f"Every new and updated task must include all variables, even they are empty array."
+ f"Dependent IDs must be smaller than the ID of the task."
+ f"New tasks IDs should be no larger than the last task ID."
+ f"Always select at least one skill."
+ f"Task IDs should be unique and in chronological order." f"Do not change the status of complete tasks."
+ f"Only add skills from the AVAILABLE SKILLS, using the exact same spelling."
+ f"Provide your array as a JSON array with double quotes. The first object is new tasks to add as a JSON array, the second array lists the ID numbers where the new tasks should be added after (number of ID numbers matches array), and the third object provides the tasks that need to be updated."
+ f"Make sure to keep dependent_task_ids key, even if an empty array."
+ f"AVAILABLE SKILLS: {skill_descriptions}.###"
+ f"\n###Here is the last task output: {task_output}"
+ f"\n###Here is the current task list: {self.tasks}"
+ f"\n###EXAMPLE OUTPUT FORMAT = {json.dumps(example)}"
+ f"\n###OUTPUT = "
+ )
+ print("\033[90m\033[3m" + "\nReflecting on task output to generate new tasks if necessary...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k-0613",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0.7,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print("\n#" + str(result))
+
+ # Check if the returned result has the expected structure
+ if isinstance(result, str):
+ try:
+ task_list = json.loads(result)
+ # print("RESULT:")
+
+ print(task_list)
+ # return [],[],[]
+ return task_list[0], task_list[1], task_list[2]
+ except Exception as error:
+ print(error)
+
+ else:
+ raise ValueError("Invalid task list structure in the output")
+
+ def get_tasks(self):
+ """
+ Returns the current list of tasks.
+
+ Returns:
+ list: the list of tasks.
+ """
+ return self.tasks
+
+ def get_task(self, task_id):
+ """
+ Returns a task given its task_id.
+
+ Parameters:
+ task_id : int
+ The unique ID of the task.
+
+ Returns:
+ dict
+ The task that matches the task_id.
+ """
+ matching_tasks = [task for task in self.tasks if task["id"] == task_id]
+
+ if matching_tasks:
+ return matching_tasks[0]
+ else:
+ print(f"No task found with id {task_id}")
+ return None
+
+ def print_tasklist(self, task_list):
+ p_tasklist="\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m"
+ for t in task_list:
+ dependent_task_ids = t.get('dependent_task_ids', [])
+ dependent_task = ""
+ if dependent_task_ids:
+ dependent_task = f"\033[31m\033[0m"
+ status_color = "\033[32m" if t.get('status') == "completed" else "\033[31m"
+ p_tasklist+= f"\033[1m{t.get('id')}\033[0m: {t.get('task')} {status_color}[{t.get('status')}]\033[0m \033[93m[{t.get('skill')}] {dependent_task}\033[0m\n"
+ print(p_tasklist)
+
+
+
+class ExampleObjectivesLoader:
+ def __init__(self, objectives_folder_path):
+ self.objectives_folder_path = objectives_folder_path
+ self.objectives_examples = [] # Initialize as an empty list
+
+ def load_objectives_examples(self):
+ self.objectives_examples = []
+ for filename in os.listdir(self.objectives_folder_path):
+ file_path = os.path.join(self.objectives_folder_path, filename)
+ with open(file_path, 'r') as file:
+ objectives = json.load(file)
+ self.objectives_examples.extend(objectives)
+
+
+ def find_most_relevant_objective(self, user_input):
+ user_input_embedding = self.get_embedding(user_input, model='text-embedding-ada-002')
+ most_relevant_objective = max(
+ self.objectives_examples,
+ key=lambda pair: self.cosine_similarity(pair['objective'], user_input_embedding)
+ )
+ return most_relevant_objective['objective'], most_relevant_objective['examples']
+
+
+ def get_embedding(self, text, model='text-embedding-ada-002'):
+ response = openai.Embedding.create(input=[text], model=model)
+ embedding = response['data'][0]['embedding']
+ return embedding
+
+ def cosine_similarity(self, objective, embedding):
+ max_similarity = float('-inf')
+ objective_embedding = self.get_embedding(objective, model='text-embedding-ada-002')
+ similarity = self.calculate_similarity(objective_embedding, embedding)
+ max_similarity = max(max_similarity, similarity)
+ return max_similarity
+
+ def calculate_similarity(self, embedding1, embedding2):
+ embedding1 = np.array(embedding1, dtype=np.float32)
+ embedding2 = np.array(embedding2, dtype=np.float32)
+ similarity = np.dot(embedding1, embedding2) / (np.linalg.norm(embedding1) * np.linalg.norm(embedding2))
+ return similarity
+
+ def load_example_objectives(self, user_objective):
+ self.load_objectives_examples()
+ most_relevant_objective, most_relevant_tasklist = self.find_most_relevant_objective(user_objective)
+ example_objective = most_relevant_objective
+ example_tasklist = most_relevant_tasklist
+ return example_objective, example_tasklist
+
\ No newline at end of file
diff --git a/classic/README.md b/classic/README.md
new file mode 100644
index 00000000..797609e0
--- /dev/null
+++ b/classic/README.md
@@ -0,0 +1,45 @@
+# babyagi
+
+
+# Objective
+This Python script is an example of an AI-powered task management system. The system uses OpenAI and Pinecone APIs to create, prioritize, and execute tasks. The main idea behind this system is that it creates tasks based on the result of previous tasks and a predefined objective. The script then uses OpenAI's natural language processing (NLP) capabilities to create new tasks based on the objective, and Pinecone to store and retrieve task results for context. This is a paired-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023).
+
+This README will cover the following:
+
+* How the script works
+
+* How to use the script
+* Warning about running the script continuously
+# How It Works
+The script works by running an infinite loop that does the following steps:
+
+1. Pulls the first task from the task list.
+2. Sends the task to the execution agent, which uses OpenAI's API to complete the task based on the context.
+3. Enriches the result and stores it in Pinecone.
+4. Creates new tasks and reprioritizes the task list based on the objective and the result of the previous task.
+The execution_agent() function is where the OpenAI API is used. It takes two parameters: the objective and the task. It then sends a prompt to OpenAI's API, which returns the result of the task. The prompt consists of a description of the AI system's task, the objective, and the task itself. The result is then returned as a string.
+
+The task_creation_agent() function is where OpenAI's API is used to create new tasks based on the objective and the result of the previous task. The function takes four parameters: the objective, the result of the previous task, the task description, and the current task list. It then sends a prompt to OpenAI's API, which returns a list of new tasks as strings. The function then returns the new tasks as a list of dictionaries, where each dictionary contains the name of the task.
+
+The prioritization_agent() function is where OpenAI's API is used to reprioritize the task list. The function takes one parameter, the ID of the current task. It sends a prompt to OpenAI's API, which returns the reprioritized task list as a numbered list.
+
+Finally, the script uses Pinecone to store and retrieve task results for context. The script creates a Pinecone index based on the table name specified in YOUR_TABLE_NAME variable. Pinecone is then used to store the results of the task in the index, along with the task name and any additional metadata.
+
+# How to Use
+To use the script, you will need to follow these steps:
+
+1. Install the required packages: `pip install -r requirements.txt`
+2. Set your OpenAI and Pinecone API keys in the OPENAI_API_KEY and PINECONE_API_KEY variables.
+3. Set the Pinecone environment in the PINECONE_ENVIRONMENT variable.
+4. Set the name of the table where the task results will be stored in the YOUR_TABLE_NAME variable.
+5. Set the objective of the task management system in the OBJECTIVE variable.
+6. Set the first task of the system in the YOUR_FIRST_TASK variable.
+7. Run the script.
+
+# Warning
+This script is designed to be run continuously as part of a task management system. Running this script continuously can result in high API usage, so please use it responsibly. Additionally, the script requires the OpenAI and Pinecone APIs to be set up correctly, so make sure you have set up the APIs before running the script.
+
+#Backstory
+BabyAGI is a paired-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) shared on Twitter. This version is down to 140 lines: 13 comments, 22 blank, 105 code. The name of the repo came up in the reaction to the original autonomous agent - the author does not mean to imply that this is AGI.
+
+Made with love by [@yoheinakajima](https://twitter.com/yoheinakajima), who happens to be a VC - so if you use this build a startup, ping him!
diff --git a/classic/babyagi.py b/classic/babyagi.py
new file mode 100644
index 00000000..55f9a768
--- /dev/null
+++ b/classic/babyagi.py
@@ -0,0 +1,138 @@
+import openai
+import pinecone
+import time
+from collections import deque
+from typing import Dict, List
+
+#Set API Keys
+OPENAI_API_KEY = ""
+PINECONE_API_KEY = ""
+PINECONE_ENVIRONMENT = "us-east1-gcp" #Pinecone Environment (eg. "us-east1-gcp")
+
+#Set Variables
+YOUR_TABLE_NAME = "test-table"
+OBJECTIVE = "Solve world hunger."
+YOUR_FIRST_TASK = "Develop a task list."
+
+#Print OBJECTIVE
+print("\033[96m\033[1m"+"\n*****OBJECTIVE*****\n"+"\033[0m\033[0m")
+print(OBJECTIVE)
+
+# Configure OpenAI and Pinecone
+openai.api_key = OPENAI_API_KEY
+pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_ENVIRONMENT)
+
+# Create Pinecone index
+table_name = YOUR_TABLE_NAME
+dimension = 1536
+metric = "cosine"
+pod_type = "p1"
+if table_name not in pinecone.list_indexes():
+ pinecone.create_index(table_name, dimension=dimension, metric=metric, pod_type=pod_type)
+
+# Connect to the index
+index = pinecone.Index(table_name)
+
+# Task list
+task_list = deque([])
+
+def add_task(task: Dict):
+ task_list.append(task)
+
+def get_ada_embedding(text):
+ text = text.replace("\n", " ")
+ return openai.Embedding.create(input=[text], model="text-embedding-ada-002")["data"][0]["embedding"]
+
+def task_creation_agent(objective: str, result: Dict, task_description: str, task_list: List[str]):
+ prompt = f"You are an task creation AI that uses the result of an execution agent to create new tasks with the following objective: {objective}, The last completed task has the result: {result}. This result was based on this task description: {task_description}. These are incomplete tasks: {', '.join(task_list)}. Based on the result, create new tasks to be completed by the AI system that do not overlap with incomplete tasks. Return the tasks as an array."
+ response = openai.Completion.create(engine="text-davinci-003",prompt=prompt,temperature=0.5,max_tokens=100,top_p=1,frequency_penalty=0,presence_penalty=0)
+ new_tasks = response.choices[0].text.strip().split('\n')
+ return [{"task_name": task_name} for task_name in new_tasks]
+
+def prioritization_agent(this_task_id:int):
+ global task_list
+ task_names = [t["task_name"] for t in task_list]
+ next_task_id = int(this_task_id)+1
+ prompt = f"""You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing the following tasks: {task_names}. Consider the ultimate objective of your team:{OBJECTIVE}. Do not remove any tasks. Return the result as a numbered list, like:
+ #. First task
+ #. Second task
+ Start the task list with number {next_task_id}."""
+ response = openai.Completion.create(engine="text-davinci-003",prompt=prompt,temperature=0.5,max_tokens=1000,top_p=1,frequency_penalty=0,presence_penalty=0)
+ new_tasks = response.choices[0].text.strip().split('\n')
+ task_list = deque()
+ for task_string in new_tasks:
+ task_parts = task_string.strip().split(".", 1)
+ if len(task_parts) == 2:
+ task_id = task_parts[0].strip()
+ task_name = task_parts[1].strip()
+ task_list.append({"task_id": task_id, "task_name": task_name})
+
+def execution_agent(objective:str,task: str) -> str:
+ #context = context_agent(index="quickstart", query="my_search_query", n=5)
+ context=context_agent(index=YOUR_TABLE_NAME, query=objective, n=5)
+ #print("\n*******RELEVANT CONTEXT******\n")
+ #print(context)
+ response = openai.Completion.create(
+ engine="text-davinci-003",
+ prompt=f"You are an AI who performs one task based on the following objective: {objective}. Your task: {task}\nResponse:",
+ temperature=0.7,
+ max_tokens=2000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+ return response.choices[0].text.strip()
+
+def context_agent(query: str, index: str, n: int):
+ query_embedding = get_ada_embedding(query)
+ index = pinecone.Index(index_name=index)
+ results = index.query(query_embedding, top_k=n,
+ include_metadata=True)
+ #print("***** RESULTS *****")
+ #print(results)
+ sorted_results = sorted(results.matches, key=lambda x: x.score, reverse=True)
+ return [(str(item.metadata['task'])) for item in sorted_results]
+
+# Add the first task
+first_task = {
+ "task_id": 1,
+ "task_name": YOUR_FIRST_TASK
+}
+
+add_task(first_task)
+# Main loop
+task_id_counter = 1
+while True:
+ if task_list:
+ # Print the task list
+ print("\033[95m\033[1m"+"\n*****TASK LIST*****\n"+"\033[0m\033[0m")
+ for t in task_list:
+ print(str(t['task_id'])+": "+t['task_name'])
+
+ # Step 1: Pull the first task
+ task = task_list.popleft()
+ print("\033[92m\033[1m"+"\n*****NEXT TASK*****\n"+"\033[0m\033[0m")
+ print(str(task['task_id'])+": "+task['task_name'])
+
+ # Send to execution function to complete the task based on the context
+ result = execution_agent(OBJECTIVE,task["task_name"])
+ this_task_id = int(task["task_id"])
+ print("\033[93m\033[1m"+"\n*****TASK RESULT*****\n"+"\033[0m\033[0m")
+ print(result)
+
+ # Step 2: Enrich result and store in Pinecone
+ enriched_result = {'data': result} # This is where you should enrich the result if needed
+ result_id = f"result_{task['task_id']}"
+ vector = enriched_result['data'] # extract the actual result from the dictionary
+ index.upsert([(result_id, get_ada_embedding(vector),{"task":task['task_name'],"result":result})])
+
+ # Step 3: Create new tasks and reprioritize task list
+ new_tasks = task_creation_agent(OBJECTIVE,enriched_result, task["task_name"], [t["task_name"] for t in task_list])
+
+ for new_task in new_tasks:
+ task_id_counter += 1
+ new_task.update({"task_id": task_id_counter})
+ add_task(new_task)
+ prioritization_agent(this_task_id)
+
+time.sleep(1) # Sleep before checking the task list again
diff --git a/classic/babyfoxagi/README.md b/classic/babyfoxagi/README.md
new file mode 100644
index 00000000..97b71907
--- /dev/null
+++ b/classic/babyfoxagi/README.md
@@ -0,0 +1,140 @@
+### Author's Note
+
+BabyFoxAGI is the 5th mod of BabyAGI. The earlier 4 were [BabyBeeAGI](https://twitter.com/yoheinakajima/status/1652732735344246784?lang=en), [BabyCatAGI](https://twitter.com/yoheinakajima/status/1657448504112091136), [BabyDeerAGI](https://twitter.com/yoheinakajima/status/1666313838868992001), and [BabyElfAGI](https://twitter.com/yoheinakajima/status/1678443482866933760). Following the evolution will be the easiest way to understand BabyFoxAGI. Please check out [the tweet thread introducing BabyFoxAGI](https://twitter.com/yoheinakajima/status/1697539193768116449) for a quick overview.
+
+### New Features in BabyFoxAGI
+
+In BabyFoxAGI, the two newest features are:
+
+1. **Self-Improvement (Also known as [FOXY Method](https://twitter.com/yoheinakajima/status/1685894298536148992))**: This helps it improve its task list building.
+2. **[BabyAGI Experimental UI](https://twitter.com/yoheinakajima/status/1693153307454546331)**: In this feature, the chat is separated from task/output.
+
+Notable in the chat is the ability to either run one skill quickly or generate a task list and chain skills, where the you see BabyAGI (moved to babyagi.py) comes in. main.py is now the back-end to the Python Flask based chat app (public/templates folder).
+
+### Known Issues and Limitations
+
+I had issues with parallel tasks within BabyAGI, so removed that for now. I'm also not streaming the task list or in-between work from these task list runs to the UI. For now, you'll have to monitor that in the console. And in general, lots more room for improvement... but wanted to get this out there :)
+
+## Getting Started
+
+These instructions will guide you through the process of setting up Classic BabyFoxAGI on your local machine.
+
+### Prerequisites
+
+Make sure you have the following software installed:
+
+- Git ([Download & Install Git](https://git-scm.com/downloads))
+- Python 3.x ([Download & Install Python](https://www.python.org/downloads/))
+- Pip (usually installed with Python)
+
+### Clone the Repository
+
+To clone this specific folder (`classic/babyfoxagi`) from the GitHub repository, open a terminal and run the following commands:
+
+```bash
+# Navigate to the directory where you want to clone the project
+cd your/desired/directory
+
+# Clone the entire repository
+git clone https://github.com/yoheinakajima/babyagi.git
+
+# Move into the cloned repository
+cd babyagi
+
+# Navigate to the 'classic/babyfoxagi' folder
+cd classic/babyfoxagi
+```
+### Install Dependencies
+Since there's no requirements.txt, you'll need to install the required packages manually:
+```bash
+# Install OpenAI package
+pip install openai
+
+# Install Flask
+pip install Flask
+```
+Note: If you are using a Python environment manager like conda, make sure to activate your environment before running the pip commands.
+### Configuration
+Create a .env file in the classic/babyfoxagi directory to store your API keys.
+```bash
+# Create a .env file
+touch .env
+
+# Open the .env file with a text editor and add your API keys
+echo "OPENAI_API_KEY=your_openai_api_key_here" >> .env
+# Add other API keys as needed for other tools (e.g., Airtable)
+echo "SERPAPI_API_KEY=your_serpapi_api_key_here" >> .env
+echo "AIRTABLE_API_KEY=your_airtable_api_key_here" >> .env
+```
+For other tools like airtable_search, you may also need to specify additional configurations like BASE, TABLE, and COLUMN in the airtable_search.py file.
+### Running the Project
+After cloning the repository, installing the dependencies, and setting up the .env file, just run:
+```bash
+python main.py
+```
+
+# BabyFoxAGI - Overview
+
+BabyFoxAGI is an experimental chat-based UI that can use a variety of skills to accomplish tasks, displayed in a separate panel from the Chat UI, allowing for parallel execution of tasks. Tasks can be accomplished quickly using one skill, or by generating a tasklist and chaining multiple tasks/skills together.
+
+## Skills
+
+Skills that are included include text_completion, web_search, drawing (uses html canvas), documentation_search, code_reader, skill_saver, airtable_search, and call_babyagi. Please read through each skill to understand them better.
+
+## Components
+
+The project consists mainly of two Python scripts (`main.py` and `babyagi.py`) and a client-side JavaScript file (`Chat.js`), along with an HTML layout (`index.html`).
+
+### main.py
+
+#### Role
+Acts as the entry point for the Flask web application and handles routes, API calls, and ongoing tasks.
+
+#### Key Features
+- Flask routes for handling HTTP requests.
+- Integration with OpenAI's API for text summarization and skill execution.
+- Management of ongoing tasks and their statuses.
+
+### Chat.js
+
+#### Role
+Handles the client-side interaction within the web interface, including capturing user input and displaying messages and task statuses.
+
+#### Key Features
+- Dynamic chat interface for user interaction.
+- HTTP requests to the Flask backend for task initiation and status checks.
+- Presentation layer for task status and results.
+
+### index.html
+
+#### Role
+Provides the layout for the web interface, including a chat box for user interaction and an objectives box for task display.
+
+#### Key Features
+- HTML layout that accommodates the chat box and objectives box side-by-side.
+
+### babyagi.py
+
+#### Role
+Acts as the central orchestrator for task execution, coordinating with various skills to accomplish a predefined objective.
+
+#### Key Features
+- Task and skill registries to manage the execution.
+- Main execution loop that iteratively performs tasks based on dependencies and objectives.
+- Optional feature to reflect on task outputs and potentially generate new tasks.
+
+## Flow of Execution
+
+1. The user interacts with the chat interface, sending commands or inquiries.
+2. `main.py` receives these requests and uses OpenAI's API to determine the next steps, which could include executing a skill or creating a task list.
+3. If tasks are to be executed, `main.py` delegates to `babyagi.py`.
+4. `babyagi.py` uses its main execution loop to perform tasks in the required sequence, based on dependencies and the main objective.
+5. The output or status of each task is sent back to the client-side via Flask routes, and displayed using `Chat.js`.
+
+## Notes
+
+- The system leverages `.env` for API key management.
+- `.ndjson` files are used for persistent storage of chat and task statuses.
+- There is an optional `REFLECTION` feature in `babyagi.py` that allows the system to reflect on task outputs and potentially generate new tasks.
+
+This overview provides a comprehensive look into the functionalities and execution flow of the project, offering both high-level insights and low-level details.
diff --git a/classic/babyfoxagi/babyagi.py b/classic/babyfoxagi/babyagi.py
new file mode 100644
index 00000000..aa230357
--- /dev/null
+++ b/classic/babyfoxagi/babyagi.py
@@ -0,0 +1,140 @@
+import os
+from dotenv import load_dotenv
+import time
+from datetime import datetime
+from skills.skill_registry import SkillRegistry
+from tasks.task_registry import TaskRegistry
+from ongoing_tasks import ongoing_tasks
+
+load_dotenv() # Load environment variables from .env file
+
+api_keys = {
+ 'openai': os.getenv('OPENAI_API_KEY'),
+ 'serpapi': os.getenv('SERPAPI_API_KEY')
+ #'airtable': os.getenv('AIRTABLE_API_KEY')
+}
+
+OBJECTIVE = "Research Yohei Nakajima and write a poem about him."
+LOAD_SKILLS = ['web_search', 'text_completion', 'code_reader','google_jobs_api_search','image_generation','startup_analysis','play_music','game_generation']
+#add web_search and documentation_search after you add SERPAPI_API_KEY in your secrets. airtable_search once you've added your AIRTABLE_API_KEY, and add base/table/column data to airtable_search.py, etc...
+REFLECTION = False #Experimental reflection step between each task run (when running tasklist)
+
+def run_single_task(task_id, task, skill_registry, task_outputs, OBJECTIVE, task_registry):
+ """Execute a single task and update its status"""
+ task_output = task_registry.execute_task(task_id, task, skill_registry, task_outputs, OBJECTIVE)
+
+ task_outputs[task_id]["output"] = task_output
+ task_outputs[task_id]["completed"] = True
+ task_outputs[task_id]["description"] = task.get('description', 'No description available')
+ task_outputs[task_id]["skill"] = task.get('skill', 'No skill information available')
+
+ if task_output:
+ task_registry.update_tasks({"id": task_id, "status": "completed", "result": task_output})
+
+ completed_task = task_registry.get_task(task_id)
+ print(f"Task #{task_id}: {completed_task.get('task')} [COMPLETED][{completed_task.get('skill')}]")
+
+ if REFLECTION:
+ new_tasks, insert_after_ids, tasks_to_update = task_registry.reflect_on_output(task_output, skill_descriptions)
+ for new_task, after_id in zip(new_tasks, insert_after_ids):
+ task_registry.add_task(new_task, after_id)
+
+ if isinstance(tasks_to_update, dict) and tasks_to_update:
+ tasks_to_update = [tasks_to_update]
+
+ for task_to_update in tasks_to_update:
+ task_registry.update_tasks(task_to_update)
+
+
+
+
+def run_main_loop(OBJECTIVE, LOAD_SKILLS, api_keys, REFLECTION=False):
+ """Main execution loop"""
+ try:
+ skill_descriptions = ",".join(f"[{skill.name}: {skill.description}]" for skill in global_skill_registry.skills.values())
+ task_registry = TaskRegistry()
+ task_registry.create_tasklist(OBJECTIVE, skill_descriptions)
+
+ skill_names = [skill.name for skill in global_skill_registry.skills.values()]
+ session_summary = f"OBJECTIVE:{OBJECTIVE}.#SKILLS:{','.join(skill_names)}.#"
+
+ task_outputs = {task["id"]: {"completed": False, "output": None} for task in task_registry.get_tasks()}
+
+ task_output = None # Initialize task_output to None
+
+ while not all(task["completed"] for task in task_outputs.values()):
+ tasks = task_registry.get_tasks()
+ task_registry.print_tasklist(tasks)
+
+ for task in tasks:
+ if task["id"] not in task_outputs:
+ task_outputs[task["id"]] = {"completed": False, "output": None}
+
+ ready_tasks = [(task["id"], task) for task in tasks if all((dep in task_outputs and task_outputs[dep]["completed"]) for dep in task.get('dependent_task_ids', [])) and not task_outputs[task["id"]]["completed"]]
+
+ for task_id, task in ready_tasks:
+ run_single_task(task_id, task, global_skill_registry, task_outputs, OBJECTIVE, task_registry)
+
+ time.sleep(0.1)
+
+ # Assuming the last task in tasks has the latest output. Adjust if your use case is different.
+ last_task_id = tasks[-1]["id"] if tasks else None
+ task_output = task_outputs[last_task_id]["output"] if last_task_id else None
+
+ task_registry.reflect_on_final(OBJECTIVE, task_registry.get_tasks(), task_output, skill_descriptions)
+ global_skill_registry.reflect_skills(OBJECTIVE, task_registry.get_tasks(), task_output, skill_descriptions)
+
+ with open(f'output/output_{datetime.now().strftime("%d_%m_%Y_%H_%M_%S")}.txt', 'w') as file:
+ file.write(session_summary)
+ print("...file saved.")
+ print("END")
+
+ return task_output # Return the last task output
+
+ except Exception as e:
+ return f"An error occurred: {e}"
+
+
+
+# Removed repeated logic for initiating skill registry
+global_skill_registry = SkillRegistry(api_keys=api_keys, main_loop_function=run_main_loop, skill_names=LOAD_SKILLS)
+
+
+def execute_skill(skill_name, objective, task_id):
+ """Execute a single skill"""
+ skill = global_skill_registry.get_skill(skill_name)
+ if skill:
+ try:
+ result = skill.execute(objective, "", objective)
+ ongoing_tasks[task_id].update({"status": "completed", "output": result})
+ except Exception as e:
+ ongoing_tasks[task_id].update({"status": "error", "error": str(e)})
+ return task_id
+ return "Skill not found :("
+
+def execute_task_list(objective, api_keys, task_id):
+ """Execute a list of tasks"""
+ try:
+ task_registry = TaskRegistry()
+ result = run_main_loop(objective, get_skills(), api_keys)
+ ongoing_tasks[task_id].update({"status": "completed", "output": result})
+ return task_registry.get_tasks(), task_id
+ except Exception as e:
+ ongoing_tasks[task_id].update({"status": "error", "error": str(e)})
+ print(f"Error in execute_task_list: {e}")
+ return task_id
+
+
+
+def get_skills():
+ """Return the global skill registry"""
+ # Removed repeated logic for initiating skill registry
+ global global_skill_registry
+ print("Returning GLOBAL SKILL REGISTRY")
+ return global_skill_registry
+
+# Removed repeated logic for initiating skill registry
+global_skill_registry = SkillRegistry(api_keys=api_keys, main_loop_function=run_main_loop, skill_names=LOAD_SKILLS)
+
+if __name__ == "__main__":
+ run_main_loop(OBJECTIVE, LOAD_SKILLS, api_keys, REFLECTION)
\ No newline at end of file
diff --git a/classic/babyfoxagi/forever_cache.ndjson b/classic/babyfoxagi/forever_cache.ndjson
new file mode 100644
index 00000000..59247e18
--- /dev/null
+++ b/classic/babyfoxagi/forever_cache.ndjson
@@ -0,0 +1 @@
+{"role": "assistant", "content": "Hey I'm BabyAGI! How can I help you today?"}
diff --git a/classic/babyfoxagi/main.py b/classic/babyfoxagi/main.py
new file mode 100644
index 00000000..b0c0e76e
--- /dev/null
+++ b/classic/babyfoxagi/main.py
@@ -0,0 +1,309 @@
+from flask import Flask, render_template, request, jsonify, send_from_directory
+import openai
+import os
+import json
+import threading
+from babyagi import get_skills, execute_skill, execute_task_list, api_keys, LOAD_SKILLS
+from ongoing_tasks import ongoing_tasks
+
+app = Flask(__name__, static_folder='public/static')
+openai.api_key = os.getenv('OPENAI_API_KEY')
+
+
+@app.route('/')
+def hello_world():
+
+ return render_template('index.html')
+
+
+FOREVER_CACHE_FILE = "forever_cache.ndjson"
+OVERALL_SUMMARY_FILE = "overall_summary.ndjson"
+
+
+@app.route('/get-all-messages', methods=["GET"])
+def get_all_messages():
+ try:
+ messages = []
+ with open("forever_cache.ndjson", "r") as file:
+ for line in file:
+ messages.append(json.loads(line))
+
+ return jsonify(messages)
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+
+def get_latest_summary():
+ with open(OVERALL_SUMMARY_FILE, 'r') as file:
+ lines = file.readlines()
+ if lines:
+ return json.loads(lines[-1])["summary"] # Return the latest summary
+ return ""
+
+
+def summarize_text(text):
+ system_message = (
+ "Your task is to generate a concise summary for the provided conversation, this will be fed to a separate AI call as context to generate responses for future user queries."
+ " The conversation contains various messages that have been exchanged between participants."
+ " Please ensure your summary captures the main points and context of the conversation without being too verbose."
+ " The summary should be limited to a maximum of 500 tokens."
+ " Here's the conversation you need to summarize:")
+
+ completion = openai.ChatCompletion.create(model="gpt-3.5-turbo-16k",
+ messages=[{
+ "role": "system",
+ "content": system_message
+ }, {
+ "role": "user",
+ "content": text
+ }])
+
+ # Extracting the content from the assistant's message
+ return completion.choices[0]['message']['content'].strip()
+
+
+def combine_summaries(overall, latest):
+ system_message = (
+ "Your task is to generate a concise summary for the provided conversation, this will be fed to a separate AI call as context to generate responses for future user queries."
+ "You will do this by combining two given summaries into one cohesive summary."
+ " Make sure to retain the key points from both summaries and create a concise, unified summary."
+ " The combined summary should not exceed 500 tokens."
+ " Here are the summaries you need to combine:")
+
+ completion = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[{
+ "role": "system",
+ "content": system_message
+ }, {
+ "role":
+ "user",
+ "content":
+ f"Overall summary: {overall}\nLatest summary: {latest}"
+ }])
+
+ # Extracting the content from the assistant's message
+ return completion.choices[0]['message']['content'].strip()
+
+
+
+def openai_function_call(user_message):
+ global ongoing_tasks
+ global global_skill_registry
+ global_skill_registry = LOAD_SKILLS
+ print("Returning GLOBAL SKILL REGISTRY")
+ print(global_skill_registry)
+
+ # Append the new user message to the forever_cache file
+ user_entry = {"role": "user", "content": user_message}
+ append_to_ndjson(FOREVER_CACHE_FILE, user_entry)
+
+ # Retrieve the last 20 stored messages
+ with open(FOREVER_CACHE_FILE, "r") as file:
+ lines = file.readlines()
+
+ last_20_messages = [json.loads(line) for line in lines][-20:]
+
+ # Always update the summary in a separate thread
+ threading.Thread(target=update_summary, args=(last_20_messages, )).start()
+
+ overall_summary = get_latest_summary()
+ print("LOAD_SKILLS")
+ print(global_skill_registry)
+ system_message = (
+ f"You are a fun happy and quirky AI chat assistant that uses Gen Z language and lots of emojis named BabyAGI with capabilities beyond chat. For every user message, you quickly analyze whether this is a request that you can simply respond via ChatCompletion, whether you need to use one of the skills provided, or whether you should create a task list and chain multiple skills together. You will always provide a message_to_user. If path is Skill or TaskList, always generate an objective. If path is Skill, ALWAYS include skill_used from one of the available skills. ###Here are your available skills: {global_skill_registry}.###For context, here is the overall summary of the chat: {overall_summary}."
+ )
+
+ completion = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {"role": "system","content": system_message},
+ *last_20_messages,
+ {"role": "user","content": user_message},
+ ],
+ functions=[{
+ "name": "determine_response_type",
+ "description":
+ "Determine whether to respond via ChatCompletion, use a skill, or create a task list. Always provide a message_to_user.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "message_to_user": {
+ "type":
+ "string",
+ "description":
+ "A message for the user, indicating the AI's action or providing the direct chat response. ALWAYS REQUIRED. Do not use line breaks."
+ },
+ "path": {
+ "type":
+ "string",
+ "enum": ["ChatCompletion", "Skill", "TaskList"], # Restrict the values to these three options
+ "description":
+ "The type of response – either 'ChatCompletion', 'Skill', or 'TaskList'"
+ },
+ "skill_used": {
+ "type":
+ "string",
+ "description":
+ f"If path is 'Skill', indicates which skill to use. If path is 'Skill', ALWAYS use skill_used. Must be one of these: {global_skill_registry}"
+ },
+ "objective": {
+ "type":
+ "string",
+ "description":
+ "If path is 'Skill' or 'TaskList', describes the main task or objective. Always include if path is 'Skill' or 'TaskList'."
+ }
+ },
+ "required": ["path", "message_to_user", "objective", "skill_used"]
+ }
+ }],
+ function_call={"name": "determine_response_type"})
+
+ # Extract AI's structured response from function call
+ response_data = completion.choices[0]['message']['function_call'][
+ 'arguments']
+ if isinstance(response_data, str):
+ response_data = json.loads(response_data)
+ print("RESPONSE DATA:")
+ print(response_data)
+ path = response_data.get("path")
+ skill_used = response_data.get("skill_used")
+ objective = response_data.get("objective")
+ task_id = generate_task_id()
+ response_data["taskId"] = task_id
+ if path == "Skill":
+ ongoing_tasks[task_id] = {
+ 'status': 'ongoing',
+ 'description': objective,
+ 'skill_used': skill_used
+ }
+ threading.Thread(target=execute_skill, args=(skill_used, objective, task_id)).start()
+ update_ongoing_tasks_file()
+ elif path == "TaskList":
+ ongoing_tasks[task_id] = {
+ 'status': 'ongoing',
+ 'description': objective,
+ 'skill_used': 'Multiple'
+ }
+ threading.Thread(target=execute_task_list, args=(objective, api_keys, task_id)).start()
+ update_ongoing_tasks_file()
+
+ return response_data
+
+
+def generate_task_id():
+ """Generates a unique task ID"""
+ return f"{str(len(ongoing_tasks) + 1)}"
+
+
+def update_summary(messages):
+ # Combine messages to form text and summarize
+ messages_text = " ".join([msg['content'] for msg in messages])
+ latest_summary = summarize_text(messages_text)
+
+ # Update overall summary
+ overall = get_latest_summary()
+ combined_summary = combine_summaries(overall, latest_summary)
+ append_to_ndjson(OVERALL_SUMMARY_FILE, {"summary": combined_summary})
+
+
+@app.route('/determine-response', methods=["POST"])
+def determine_response():
+ try:
+ # Ensure that the request contains JSON data
+ if not request.is_json:
+ return jsonify({"error": "Expected JSON data"}), 400
+
+ user_message = request.json.get("user_message")
+
+ # Check if user_message is provided
+ if not user_message:
+ return jsonify({"error": "user_message field is required"}), 400
+
+ response_data = openai_function_call(user_message)
+
+ data = {
+ "message": response_data['message_to_user'],
+ "skill_used": response_data.get('skill_used', None),
+ "objective": response_data.get('objective', None),
+ "task_list": response_data.get('task_list', []),
+ "path": response_data.get('path', []),
+ "task_id": response_data.get('taskId')
+ }
+
+ # Storing AI's response to NDJSON file
+ ai_entry = {
+ "role": "assistant",
+ "content": response_data['message_to_user']
+ }
+ append_to_ndjson("forever_cache.ndjson", ai_entry)
+
+ print("END OF DETERMINE-RESPONSE. PRINTING 'DATA'")
+ print(data)
+ return jsonify(data)
+
+ except Exception as e:
+ print(f"Exception occurred: {str(e)}")
+ return jsonify({"error": str(e)}), 500
+
+
+def append_to_ndjson(filename, data):
+ try:
+ print(f"Appending to {filename} with data: {data}")
+ with open(filename, 'a') as file:
+ file.write(json.dumps(data) + '\n')
+ except Exception as e:
+ print(f"Error in append_to_ndjson: {str(e)}")
+
+
+
+@app.route('/check-task-status/', methods=["GET"])
+def check_task_status(task_id):
+ global ongoing_tasks
+ update_ongoing_tasks_file()
+ print("CHECK_TASK_STATUS")
+ print(task_id)
+ task = ongoing_tasks.get(task_id)
+
+ # First check if task is None
+ if not task:
+ return jsonify({"error": f"No task with ID {task_id} found."}), 404
+
+ # Now, it's safe to access attributes of task
+ print(task.get("status"))
+ return jsonify({"status": task.get("status")})
+
+
+@app.route('/fetch-task-output/', methods=["GET"])
+def fetch_task_output(task_id):
+ print("FETCH_TASK_STATUS")
+ print(task_id)
+ task = ongoing_tasks.get(task_id)
+ if not task:
+ return jsonify({"error": f"No task with ID {task_id} found."}), 404
+ return jsonify({"output": task.get("output")})
+
+
+def update_ongoing_tasks_file():
+ with open("ongoing_tasks.py", "w") as file:
+ file.write(f"ongoing_tasks = {ongoing_tasks}\n")
+
+@app.route('/get-all-tasks', methods=['GET'])
+def get_all_tasks():
+ tasks = []
+ for task_id, task_data in ongoing_tasks.items():
+ task = {
+ 'task_id': task_id,
+ 'status': task_data.get('status', 'unknown'),
+ 'description': task_data.get('description', 'N/A'),
+ 'skill_used': task_data.get('skill_used', 'N/A'),
+ 'output': task_data.get('output', 'N/A')
+ }
+ tasks.append(task)
+ return jsonify(tasks)
+
+
+
+if __name__ == "__main__":
+ app.run(host='0.0.0.0', port=8080)
diff --git a/classic/babyfoxagi/ongoing_tasks.py b/classic/babyfoxagi/ongoing_tasks.py
new file mode 100644
index 00000000..dab08f19
--- /dev/null
+++ b/classic/babyfoxagi/ongoing_tasks.py
@@ -0,0 +1 @@
+ongoing_tasks = {}
diff --git a/babyagi/functionz/core/__init__.py b/classic/babyfoxagi/overall_summary.ndjson
similarity index 100%
rename from babyagi/functionz/core/__init__.py
rename to classic/babyfoxagi/overall_summary.ndjson
diff --git a/classic/babyfoxagi/poetry.lock b/classic/babyfoxagi/poetry.lock
new file mode 100644
index 00000000..74d839a8
--- /dev/null
+++ b/classic/babyfoxagi/poetry.lock
@@ -0,0 +1,886 @@
+[[package]]
+name = "aiohttp"
+version = "3.8.5"
+description = "Async http client/server framework (asyncio)"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+aiosignal = ">=1.1.2"
+async-timeout = ">=4.0.0a3,<5.0"
+attrs = ">=17.3.0"
+charset-normalizer = ">=2.0,<4.0"
+frozenlist = ">=1.1.1"
+multidict = ">=4.5,<7.0"
+yarl = ">=1.0,<2.0"
+
+[package.extras]
+speedups = ["aiodns", "brotli", "cchardet"]
+
+[[package]]
+name = "aiohttp-retry"
+version = "2.8.3"
+description = "Simple retry client for aiohttp"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+aiohttp = "*"
+
+[[package]]
+name = "aiosignal"
+version = "1.2.0"
+description = "aiosignal: a list of registered asynchronous callbacks"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+frozenlist = ">=1.1.0"
+
+[[package]]
+name = "async-timeout"
+version = "4.0.2"
+description = "Timeout context manager for asyncio programs"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "attrs"
+version = "22.1.0"
+description = "Classes Without Boilerplate"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.extras]
+dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit", "cloudpickle"]
+docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"]
+tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "cloudpickle"]
+tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "cloudpickle"]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.12.2"
+description = "Screen-scraping library"
+category = "main"
+optional = false
+python-versions = ">=3.6.0"
+
+[package.dependencies]
+soupsieve = ">1.2"
+
+[package.extras]
+html5lib = ["html5lib"]
+lxml = ["lxml"]
+
+[[package]]
+name = "bs4"
+version = "0.0.1"
+description = "Dummy package for Beautiful Soup"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+beautifulsoup4 = "*"
+
+[[package]]
+name = "cachetools"
+version = "5.3.1"
+description = "Extensible memoizing collections and decorators"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "certifi"
+version = "2022.9.24"
+description = "Python package for providing Mozilla's CA Bundle."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "charset-normalizer"
+version = "2.1.1"
+description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
+category = "main"
+optional = false
+python-versions = ">=3.6.0"
+
+[package.extras]
+unicode_backport = ["unicodedata2"]
+
+[[package]]
+name = "click"
+version = "8.1.3"
+description = "Composable command line interface toolkit"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[[package]]
+name = "colorama"
+version = "0.4.5"
+description = "Cross-platform colored terminal text."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "datadispatch"
+version = "1.0.0"
+description = "Like functools.singledispatch but for values"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "debugpy"
+version = "1.6.3"
+description = "An implementation of the Debug Adapter Protocol for Python"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "flask"
+version = "2.2.2"
+description = "A simple framework for building complex web applications."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+click = ">=8.0"
+importlib-metadata = {version = ">=3.6.0", markers = "python_version < \"3.10\""}
+itsdangerous = ">=2.0"
+Jinja2 = ">=3.0"
+Werkzeug = ">=2.2.2"
+
+[package.extras]
+async = ["asgiref (>=3.2)"]
+dotenv = ["python-dotenv"]
+
+[[package]]
+name = "frozenlist"
+version = "1.3.1"
+description = "A list-like structure which implements collections.abc.MutableSequence"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "google-api-core"
+version = "2.11.1"
+description = "Google API client core library"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+google-auth = ">=2.14.1,<3.0.dev0"
+googleapis-common-protos = ">=1.56.2,<2.0.dev0"
+protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<5.0.0.dev0"
+requests = ">=2.18.0,<3.0.0.dev0"
+
+[package.extras]
+grpc = ["grpcio (>=1.33.2,<2.0dev)", "grpcio-status (>=1.33.2,<2.0.dev0)", "grpcio (>=1.49.1,<2.0dev)", "grpcio-status (>=1.49.1,<2.0.dev0)"]
+grpcgcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
+grpcio-gcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"]
+
+[[package]]
+name = "google-api-python-client"
+version = "2.97.0"
+description = "Google API Client Library for Python"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+google-api-core = ">=1.31.5,<2.0.0 || >2.3.0,<3.0.0.dev0"
+google-auth = ">=1.19.0,<3.0.0.dev0"
+google-auth-httplib2 = ">=0.1.0"
+httplib2 = ">=0.15.0,<1.dev0"
+uritemplate = ">=3.0.1,<5"
+
+[[package]]
+name = "google-auth"
+version = "2.22.0"
+description = "Google Authentication Library"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+cachetools = ">=2.0.0,<6.0"
+pyasn1-modules = ">=0.2.1"
+rsa = ">=3.1.4,<5"
+six = ">=1.9.0"
+urllib3 = "<2.0"
+
+[package.extras]
+aiohttp = ["aiohttp (>=3.6.2,<4.0.0.dev0)", "requests (>=2.20.0,<3.0.0.dev0)"]
+enterprise_cert = ["cryptography (==36.0.2)", "pyopenssl (==22.0.0)"]
+pyopenssl = ["pyopenssl (>=20.0.0)", "cryptography (>=38.0.3)"]
+reauth = ["pyu2f (>=0.1.5)"]
+requests = ["requests (>=2.20.0,<3.0.0.dev0)"]
+
+[[package]]
+name = "google-auth-httplib2"
+version = "0.1.0"
+description = "Google Authentication Library: httplib2 transport"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+google-auth = "*"
+httplib2 = ">=0.15.0"
+six = "*"
+
+[[package]]
+name = "googleapis-common-protos"
+version = "1.60.0"
+description = "Common protobufs used in Google APIs"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<5.0.0.dev0"
+
+[package.extras]
+grpc = ["grpcio (>=1.44.0,<2.0.0.dev0)"]
+
+[[package]]
+name = "grpcio"
+version = "1.57.0"
+description = "HTTP/2-based RPC framework"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.extras]
+protobuf = ["grpcio-tools (>=1.57.0)"]
+
+[[package]]
+name = "httplib2"
+version = "0.22.0"
+description = "A comprehensive HTTP client library."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[package.dependencies]
+pyparsing = {version = ">=2.4.2,<3.0.0 || >3.0.0,<3.0.1 || >3.0.1,<3.0.2 || >3.0.2,<3.0.3 || >3.0.3,<4", markers = "python_version > \"3.0\""}
+
+[[package]]
+name = "idna"
+version = "3.4"
+description = "Internationalized Domain Names in Applications (IDNA)"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[[package]]
+name = "importlib-metadata"
+version = "5.0.0"
+description = "Read metadata from Python packages"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+zipp = ">=0.5"
+
+[package.extras]
+docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "jaraco.tidelift (>=1.4)"]
+perf = ["ipython"]
+testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "flake8 (<5)", "pytest-cov", "pytest-enabler (>=1.3)", "packaging", "pyfakefs", "flufl.flake8", "pytest-perf (>=0.9.2)", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)", "importlib-resources (>=1.3)"]
+
+[[package]]
+name = "itsdangerous"
+version = "2.1.2"
+description = "Safely pass data to untrusted environments and back."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "jedi"
+version = "0.18.1"
+description = "An autocompletion tool for Python that can be used for text editors."
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+parso = ">=0.8.0,<0.9.0"
+
+[package.extras]
+qa = ["flake8 (==3.8.3)", "mypy (==0.782)"]
+testing = ["Django (<3.1)", "colorama", "docopt", "pytest (<7.0.0)"]
+
+[[package]]
+name = "jinja2"
+version = "3.1.2"
+description = "A very fast and expressive template engine."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+MarkupSafe = ">=2.0"
+
+[package.extras]
+i18n = ["Babel (>=2.7)"]
+
+[[package]]
+name = "markupsafe"
+version = "2.1.1"
+description = "Safely add untrusted strings to HTML/XML markup."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "multidict"
+version = "6.0.2"
+description = "multidict implementation"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "numpy"
+version = "1.23.4"
+description = "NumPy is the fundamental package for array computing with Python."
+category = "main"
+optional = false
+python-versions = ">=3.8"
+
+[[package]]
+name = "openai"
+version = "0.27.8"
+description = "Python client library for the OpenAI API"
+category = "main"
+optional = false
+python-versions = ">=3.7.1"
+
+[package.dependencies]
+aiohttp = "*"
+requests = ">=2.20"
+tqdm = "*"
+
+[package.extras]
+datalib = ["numpy", "pandas (>=1.2.3)", "pandas-stubs (>=1.1.0.11)", "openpyxl (>=3.0.7)"]
+dev = ["black (>=21.6b0,<22.0.0)", "pytest (>=6.0.0,<7.0.0)", "pytest-asyncio", "pytest-mock"]
+embeddings = ["scikit-learn (>=1.0.2)", "tenacity (>=8.0.1)", "matplotlib", "plotly", "numpy", "scipy", "pandas (>=1.2.3)", "pandas-stubs (>=1.1.0.11)", "openpyxl (>=3.0.7)"]
+wandb = ["wandb", "numpy", "pandas (>=1.2.3)", "pandas-stubs (>=1.1.0.11)", "openpyxl (>=3.0.7)"]
+
+[[package]]
+name = "packaging"
+version = "21.3"
+description = "Core utilities for Python packages"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+pyparsing = ">=2.0.2,<3.0.5 || >3.0.5"
+
+[[package]]
+name = "parso"
+version = "0.8.3"
+description = "A Python Parser"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+qa = ["flake8 (==3.8.3)", "mypy (==0.782)"]
+testing = ["docopt", "pytest (<6.0.0)"]
+
+[[package]]
+name = "pluggy"
+version = "1.0.0"
+description = "plugin and hook calling mechanisms for python"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+testing = ["pytest-benchmark", "pytest"]
+dev = ["tox", "pre-commit"]
+
+[[package]]
+name = "protobuf"
+version = "4.24.2"
+description = ""
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "pyasn1"
+version = "0.5.0"
+description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs (X.208)"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
+
+[[package]]
+name = "pyasn1-modules"
+version = "0.3.0"
+description = "A collection of ASN.1-based protocols modules"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
+
+[package.dependencies]
+pyasn1 = ">=0.4.6,<0.6.0"
+
+[[package]]
+name = "pyflakes"
+version = "2.5.0"
+description = "passive checker of Python programs"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "pyjwt"
+version = "2.8.0"
+description = "JSON Web Token implementation in Python"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.extras]
+crypto = ["cryptography (>=3.4.0)"]
+dev = ["sphinx (>=4.5.0,<5.0.0)", "sphinx-rtd-theme", "zope.interface", "cryptography (>=3.4.0)", "pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)", "pre-commit"]
+docs = ["sphinx (>=4.5.0,<5.0.0)", "sphinx-rtd-theme", "zope.interface"]
+tests = ["pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)"]
+
+[[package]]
+name = "pyparsing"
+version = "3.0.9"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+category = "main"
+optional = false
+python-versions = ">=3.6.8"
+
+[package.extras]
+diagrams = ["railroad-diagrams", "jinja2"]
+
+[[package]]
+name = "python-dotenv"
+version = "1.0.0"
+description = "Read key-value pairs from a .env file and set them as environment variables"
+category = "main"
+optional = false
+python-versions = ">=3.8"
+
+[package.extras]
+cli = ["click (>=5.0)"]
+
+[[package]]
+name = "python-lsp-jsonrpc"
+version = "1.0.0"
+description = "JSON RPC 2.0 server library"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+ujson = ">=3.0.0"
+
+[package.extras]
+test = ["coverage", "pytest-cov", "pytest", "pyflakes", "pycodestyle", "pylint"]
+
+[[package]]
+name = "pytoolconfig"
+version = "1.2.2"
+description = "Python tool configuration"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+packaging = ">=21.3"
+tomli = {version = ">=2.0", markers = "python_version < \"3.11\""}
+
+[package.extras]
+validation = ["pydantic (>=1.7.4)"]
+global = ["appdirs (>=1.4.4)"]
+gen_docs = ["pytoolconfig", "sphinx-rtd-theme (>=1.0.0)", "sphinx-autodoc-typehints (>=1.18.1)", "sphinx (>=4.5.0)"]
+doc = ["sphinx (>=4.5.0)", "tabulate (>=0.8.9)"]
+
+[[package]]
+name = "pytz"
+version = "2023.3"
+description = "World timezone definitions, modern and historical"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "replit"
+version = "3.2.4"
+description = "A library for interacting with features of repl.it"
+category = "main"
+optional = false
+python-versions = ">=3.8,<4.0"
+
+[package.dependencies]
+aiohttp = ">=3.6.2,<4.0.0"
+Flask = ">=2.0.0,<3.0.0"
+requests = ">=2.25.1,<3.0.0"
+typing_extensions = ">=3.7.4,<4.0.0"
+Werkzeug = ">=2.0.0,<3.0.0"
+
+[[package]]
+name = "replit-python-lsp-server"
+version = "1.15.9"
+description = "Python Language Server for the Language Server Protocol"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+jedi = ">=0.17.2,<0.19.0"
+pluggy = ">=1.0.0"
+pyflakes = {version = ">=2.5.0,<2.6.0", optional = true, markers = "extra == \"pyflakes\""}
+python-lsp-jsonrpc = ">=1.0.0"
+rope = {version = ">0.10.5", optional = true, markers = "extra == \"rope\""}
+toml = ">=0.10.2"
+ujson = ">=3.0.0"
+whatthepatch = {version = ">=1.0.2,<2.0.0", optional = true, markers = "extra == \"yapf\""}
+yapf = {version = "*", optional = true, markers = "extra == \"yapf\""}
+
+[package.extras]
+all = ["autopep8 (>=1.6.0,<1.7.0)", "flake8 (>=5.0.0,<5.1.0)", "mccabe (>=0.7.0,<0.8.0)", "pycodestyle (>=2.9.0,<2.10.0)", "pydocstyle (>=2.0.0)", "pyflakes (>=2.5.0,<2.6.0)", "pylint (>=2.5.0)", "rope (>=0.10.5)", "yapf", "whatthepatch"]
+autopep8 = ["autopep8 (>=1.6.0,<1.7.0)"]
+flake8 = ["flake8 (>=5.0.0,<5.1.0)"]
+mccabe = ["mccabe (>=0.7.0,<0.8.0)"]
+pycodestyle = ["pycodestyle (>=2.9.0,<2.10.0)"]
+pydocstyle = ["pydocstyle (>=2.0.0)"]
+pyflakes = ["pyflakes (>=2.5.0,<2.6.0)"]
+pylint = ["pylint (>=2.5.0)"]
+rope = ["rope (>0.10.5)"]
+test = ["pylint (>=2.5.0)", "pytest", "pytest-cov", "coverage", "numpy (<1.23)", "pandas", "matplotlib", "pyqt5", "flaky"]
+websockets = ["websockets (>=10.3)"]
+yapf = ["yapf", "whatthepatch (>=1.0.2,<2.0.0)"]
+
+[[package]]
+name = "requests"
+version = "2.28.1"
+description = "Python HTTP for Humans."
+category = "main"
+optional = false
+python-versions = ">=3.7, <4"
+
+[package.dependencies]
+certifi = ">=2017.4.17"
+charset-normalizer = ">=2,<3"
+idna = ">=2.5,<4"
+urllib3 = ">=1.21.1,<1.27"
+
+[package.extras]
+socks = ["PySocks (>=1.5.6,!=1.5.7)"]
+use_chardet_on_py3 = ["chardet (>=3.0.2,<6)"]
+
+[[package]]
+name = "rope"
+version = "1.3.0"
+description = "a python refactoring library..."
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+pytoolconfig = ">=1.1.2"
+
+[package.extras]
+doc = ["sphinx-rtd-theme (>=1.0.0)", "sphinx-autodoc-typehints (>=1.18.1)", "sphinx (>=4.5.0)", "pytoolconfig"]
+dev = ["build (>=0.7.0)", "pytest-timeout (>=2.1.0)", "pytest (>=7.0.1)"]
+
+[[package]]
+name = "rsa"
+version = "4.9"
+description = "Pure-Python RSA implementation"
+category = "main"
+optional = false
+python-versions = ">=3.6,<4"
+
+[package.dependencies]
+pyasn1 = ">=0.1.3"
+
+[[package]]
+name = "six"
+version = "1.16.0"
+description = "Python 2 and 3 compatibility utilities"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "skills"
+version = "0.3.0"
+description = "Implementation of the TrueSkill, Glicko and Elo Ranking Algorithms"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "soupsieve"
+version = "2.4.1"
+description = "A modern CSS selector implementation for Beautiful Soup."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "tasks"
+version = "2.8.0"
+description = "A simple personal task queue to track todo items"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+datadispatch = "*"
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
+category = "dev"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "tomli"
+version = "2.0.1"
+description = "A lil' TOML parser"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "tqdm"
+version = "4.66.1"
+description = "Fast, Extensible Progress Meter"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[package.extras]
+dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"]
+notebook = ["ipywidgets (>=6)"]
+slack = ["slack-sdk"]
+telegram = ["requests"]
+
+[[package]]
+name = "twilio"
+version = "8.5.0"
+description = "Twilio API client and TwiML generator"
+category = "main"
+optional = false
+python-versions = ">=3.7.0"
+
+[package.dependencies]
+aiohttp = ">=3.8.4"
+aiohttp-retry = ">=2.8.3"
+PyJWT = ">=2.0.0,<3.0.0"
+pytz = "*"
+requests = ">=2.0.0"
+
+[[package]]
+name = "typing-extensions"
+version = "3.10.0.2"
+description = "Backported and Experimental Type Hints for Python 3.5+"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "ujson"
+version = "5.5.0"
+description = "Ultra fast JSON encoder and decoder for Python"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[[package]]
+name = "uritemplate"
+version = "4.1.1"
+description = "Implementation of RFC 6570 URI Templates"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "urllib3"
+version = "1.26.12"
+description = "HTTP library with thread-safe connection pooling, file post, and more."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, <4"
+
+[package.extras]
+brotli = ["brotlicffi (>=0.8.0)", "brotli (>=1.0.9)", "brotlipy (>=0.6.0)"]
+secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "urllib3-secure-extra", "ipaddress"]
+socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
+
+[[package]]
+name = "werkzeug"
+version = "2.2.2"
+description = "The comprehensive WSGI web application library."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+MarkupSafe = ">=2.1.1"
+
+[package.extras]
+watchdog = ["watchdog"]
+
+[[package]]
+name = "whatthepatch"
+version = "1.0.2"
+description = "A patch parsing and application library."
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "xds-protos"
+version = "0.0.11"
+description = "Generated Python code from envoyproxy/data-plane-api"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+grpcio = "*"
+protobuf = "*"
+
+[[package]]
+name = "yapf"
+version = "0.32.0"
+description = "A formatter for Python code."
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "yarl"
+version = "1.8.1"
+description = "Yet another URL library"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+idna = ">=2.0"
+multidict = ">=4.0"
+
+[[package]]
+name = "zipp"
+version = "3.9.0"
+description = "Backport of pathlib-compatible object wrapper for zip files"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.extras]
+docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "jaraco.tidelift (>=1.4)"]
+testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "flake8 (<5)", "pytest-cov", "pytest-enabler (>=1.3)", "jaraco.itertools", "func-timeout", "jaraco.functools", "more-itertools", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)"]
+
+[metadata]
+lock-version = "1.1"
+python-versions = ">=3.8.0,<3.9"
+content-hash = "c0a0faf8c1bfce437b0517d539ce578ac47df821f02234e0c3ad58c35c88ea34"
+
+[metadata.files]
+aiohttp = []
+aiohttp-retry = []
+aiosignal = []
+async-timeout = []
+attrs = []
+beautifulsoup4 = []
+bs4 = []
+cachetools = []
+certifi = []
+charset-normalizer = []
+click = []
+colorama = []
+datadispatch = []
+debugpy = []
+flask = []
+frozenlist = []
+google-api-core = []
+google-api-python-client = []
+google-auth = []
+google-auth-httplib2 = []
+googleapis-common-protos = []
+grpcio = []
+httplib2 = []
+idna = []
+importlib-metadata = []
+itsdangerous = []
+jedi = []
+jinja2 = []
+markupsafe = []
+multidict = []
+numpy = []
+openai = []
+packaging = []
+parso = []
+pluggy = []
+protobuf = []
+pyasn1 = []
+pyasn1-modules = []
+pyflakes = []
+pyjwt = []
+pyparsing = []
+python-dotenv = []
+python-lsp-jsonrpc = []
+pytoolconfig = []
+pytz = []
+replit = []
+replit-python-lsp-server = []
+requests = []
+rope = []
+rsa = []
+six = []
+skills = []
+soupsieve = []
+tasks = []
+toml = []
+tomli = []
+tqdm = []
+twilio = []
+typing-extensions = []
+ujson = []
+uritemplate = []
+urllib3 = []
+werkzeug = []
+whatthepatch = []
+xds-protos = []
+yapf = []
+yarl = []
+zipp = []
diff --git a/classic/babyfoxagi/public/static/chat.js b/classic/babyfoxagi/public/static/chat.js
new file mode 100644
index 00000000..a7872ef3
--- /dev/null
+++ b/classic/babyfoxagi/public/static/chat.js
@@ -0,0 +1,279 @@
+ // Display message function
+ function displayMessage(content, role = "user") {
+ let messageHTML = createMessageHTML(content, role);
+ $("#chat-messages").append(messageHTML);
+ if (role === "ongoing") {
+ $(".bg-green-100:last").parent().addClass("ai-processing");
+ }
+ }
+
+ function createMessageHTML(content, role) {
+ if (role === "user") {
+ return `
`;
+ $("#task-list").prepend(taskHTML);
+}
+
+
+function updateTaskStatus(taskId, status, output) {
+ const $taskToUpdate = $(`#task-list > .task-item[data-task-id="${taskId}"]`);
+
+ // Remove the existing status badge
+ $taskToUpdate.find(".status-badge").remove();
+
+ // Insert the new status badge right before the skill badge
+ $taskToUpdate.find(".toggle-output-icon").after(getStatusBadgeHTML(status));
+
+ // Update output, if available
+ const $outputContainer = $taskToUpdate.find(".task-output");
+ if (output) {
+ $outputContainer.html(`
${output}
`);
+ } else {
+ $outputContainer.find("p").text("No output yet...");
+ }
+}
+
+function loadAllTasks() {
+ $.ajax({
+ type: 'GET',
+ url: '/get-all-tasks',
+ dataType: 'json',
+ success(data) {
+ console.log("Debug: Received tasks:", data); // Debug print
+ data.forEach(task => {
+ const description = task.description || '';
+ const status = task.status || '';
+ const skill_used = task.skill_used || '';
+ const task_id = task.task_id || '';
+ const output = task.output || null; // Get the output, if it exists, otherwise set to null
+ displayTaskWithStatus(description, status, skill_used, task_id, output);
+ });
+ },
+ error(error) {
+ console.error("Error fetching all tasks:", error);
+ }
+ });
+}
+
+
+
+
+
+
+$(document).on('click', '.toggle-output-icon', function() {
+ const $task = $(this).closest(".task-item");
+ const $output = $task.find(".task-output");
+ $output.toggleClass('hidden');
+ // Change the icon when the output is toggled
+ const icon = $(this);
+ if ($output.hasClass('hidden')) {
+ icon.text('▶'); // Icon indicating the output is hidden
+ } else {
+ icon.text('▼'); // Icon indicating the output is shown
+ }
+});
diff --git a/classic/babyfoxagi/public/static/style.css b/classic/babyfoxagi/public/static/style.css
new file mode 100644
index 00000000..8e35631f
--- /dev/null
+++ b/classic/babyfoxagi/public/static/style.css
@@ -0,0 +1,97 @@
+body::before {
+ content: "";
+ position: fixed;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ z-index: -1;
+ background-image:
+ linear-gradient(45deg, rgba(250, 243, 224, 0.1) 25%, transparent 25%, transparent 50%, rgba(250, 243, 224, 0.1) 50%, rgba(250, 243, 224, 0.1) 75%, transparent 75%, transparent);
+ background-size: 40px 40px;
+}
+
+body {
+ background-color: #ffffff;
+ opacity: 0.8;
+ background-image: linear-gradient(135deg, #fff2ce 25%, transparent 25%), linear-gradient(225deg, #fff2ce 25%, transparent 25%), linear-gradient(45deg, #fff2ce 25%, transparent 25%), linear-gradient(315deg, #fff2ce 25%, #ffffff 25%);
+ background-position: 10px 0, 10px 0, 0 0, 0 0;
+ background-size: 10px 10px;
+ background-repeat: repeat;
+ font-family: 'Montserrat';
+}
+
+
+
+
+.chat-box {
+
+ background-color: #faf3e0; /* Light beige */
+}
+.objectives-box {
+ background-color: #faf3e0; /* Light beige */
+}
+#task-list {
+ background-color: #fff; /* Light beige */
+}
+
+.chat-messages {
+ overflow-y: scroll;
+ background-color: #fff
+ /* background-color: #faf3e0; /* Light beige */
+}
+
+/* Style for user's speech bubble tail */
+.bg-blue-200::before {
+ content: "";
+ position: absolute;
+ top: 10px;
+ right: -10px;
+ border-width: 10px;
+ border-style: solid;
+ border-color: transparent transparent transparent;
+}
+
+/* Style for assistant's speech bubble tail */
+.bg-gray-300::before {
+ content: "";
+ position: absolute;
+ top: 10px;
+ left: -10px;
+ border-width: 10px;
+ border-style: solid;
+ border-color: transparent transparent transparent;
+}
+
+
+.task-item {
+ border: 1px solid #fffbe7;
+ border-radius: 8px;
+ margin-bottom: 10px;
+ padding: 10px;
+ position: relative;
+}
+
+.task-title {
+ font-weight: bold;
+}
+
+.task-output {
+ margin-top: 10px;
+}
+
+.show-output .task-output {
+ display: block;
+}
+
+#task-list {
+ overflow-y: auto;
+ max-height: calc(100vh - 150px); /* Adjust based on header and padding */
+}
+
+.task-output {
+ background-color: #fffdfd; /* Light gray */
+ padding: 10px;
+ border-radius: 5px;
+ margin-top: 5px;
+}
diff --git a/classic/babyfoxagi/pyproject.toml b/classic/babyfoxagi/pyproject.toml
new file mode 100644
index 00000000..bcb0297b
--- /dev/null
+++ b/classic/babyfoxagi/pyproject.toml
@@ -0,0 +1,28 @@
+[tool.poetry]
+name = "python-template"
+version = "0.1.0"
+description = ""
+authors = ["Your Name "]
+
+[tool.poetry.dependencies]
+python = ">=3.8.0,<3.9"
+numpy = "^1.22.2"
+replit = "^3.2.4"
+Flask = "^2.2.0"
+urllib3 = "^1.26.12"
+openai = "^0.27.8"
+tasks = "^2.8.0"
+python-dotenv = "^1.0.0"
+skills = "^0.3.0"
+bs4 = "^0.0.1"
+twilio = "^8.5.0"
+google-api-python-client = "^2.97.0"
+xds-protos = "^0.0.11"
+
+[tool.poetry.dev-dependencies]
+debugpy = "^1.6.2"
+replit-python-lsp-server = {extras = ["yapf", "rope", "pyflakes"], version = "^1.5.9"}
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
\ No newline at end of file
diff --git a/babyagi/functionz/db/__init__.py b/classic/babyfoxagi/skills/__init__.py
similarity index 100%
rename from babyagi/functionz/db/__init__.py
rename to classic/babyfoxagi/skills/__init__.py
diff --git a/classic/babyfoxagi/skills/__pycache__/__init__.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 00000000..9796b8b6
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/__init__.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/airtable_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/airtable_search.cpython-310.pyc
new file mode 100644
index 00000000..90dc146e
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/airtable_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/airtable_search.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/airtable_search.cpython-38.pyc
new file mode 100644
index 00000000..72453d97
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/airtable_search.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/call_babyagi.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/call_babyagi.cpython-310.pyc
new file mode 100644
index 00000000..2deb4e61
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/call_babyagi.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/code_reader.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/code_reader.cpython-310.pyc
new file mode 100644
index 00000000..8fba661e
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/code_reader.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/code_reader.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/code_reader.cpython-38.pyc
new file mode 100644
index 00000000..f3308970
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/code_reader.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/create_google_slides.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/create_google_slides.cpython-38.pyc
new file mode 100644
index 00000000..66a7f2bf
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/create_google_slides.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/crunchbase_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/crunchbase_search.cpython-310.pyc
new file mode 100644
index 00000000..544fe804
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/crunchbase_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/crunchbase_search.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/crunchbase_search.cpython-38.pyc
new file mode 100644
index 00000000..1826909c
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/crunchbase_search.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/directory_structure.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/directory_structure.cpython-310.pyc
new file mode 100644
index 00000000..f57ad2cf
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/directory_structure.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/documentation_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/documentation_search.cpython-310.pyc
new file mode 100644
index 00000000..90db45fe
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/documentation_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/drawing.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/drawing.cpython-38.pyc
new file mode 100644
index 00000000..d613025a
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/drawing.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/game_generation.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/game_generation.cpython-38.pyc
new file mode 100644
index 00000000..b5a76854
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/game_generation.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/google_jobs_api_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/google_jobs_api_search.cpython-310.pyc
new file mode 100644
index 00000000..9fada382
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/google_jobs_api_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/google_jobs_api_search.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/google_jobs_api_search.cpython-38.pyc
new file mode 100644
index 00000000..74d7634c
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/google_jobs_api_search.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/image_generation.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/image_generation.cpython-38.pyc
new file mode 100644
index 00000000..477e57cd
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/image_generation.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/news_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/news_search.cpython-310.pyc
new file mode 100644
index 00000000..00577417
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/news_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/objective_saver.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/objective_saver.cpython-310.pyc
new file mode 100644
index 00000000..dfdb40f5
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/objective_saver.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/play_music.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/play_music.cpython-38.pyc
new file mode 100644
index 00000000..c80af970
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/play_music.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/producthunt_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/producthunt_search.cpython-310.pyc
new file mode 100644
index 00000000..5359b287
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/producthunt_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/skill.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/skill.cpython-310.pyc
new file mode 100644
index 00000000..1627eb66
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/skill.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/skill.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/skill.cpython-38.pyc
new file mode 100644
index 00000000..5dffc235
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/skill.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/skill_registry.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/skill_registry.cpython-310.pyc
new file mode 100644
index 00000000..88cac430
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/skill_registry.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/skill_registry.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/skill_registry.cpython-38.pyc
new file mode 100644
index 00000000..369d79bb
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/skill_registry.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/skill_saver.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/skill_saver.cpython-310.pyc
new file mode 100644
index 00000000..8c603607
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/skill_saver.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/startup_analysis.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/startup_analysis.cpython-38.pyc
new file mode 100644
index 00000000..8ebaf903
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/startup_analysis.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/text_completion.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/text_completion.cpython-310.pyc
new file mode 100644
index 00000000..b063a69a
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/text_completion.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/text_completion.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/text_completion.cpython-38.pyc
new file mode 100644
index 00000000..67ad0db2
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/text_completion.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/web_search.cpython-310.pyc b/classic/babyfoxagi/skills/__pycache__/web_search.cpython-310.pyc
new file mode 100644
index 00000000..9de3dfdd
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/web_search.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/skills/__pycache__/web_search.cpython-38.pyc b/classic/babyfoxagi/skills/__pycache__/web_search.cpython-38.pyc
new file mode 100644
index 00000000..d7159b76
Binary files /dev/null and b/classic/babyfoxagi/skills/__pycache__/web_search.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/skills/airtable_search.py b/classic/babyfoxagi/skills/airtable_search.py
new file mode 100644
index 00000000..e61f1914
--- /dev/null
+++ b/classic/babyfoxagi/skills/airtable_search.py
@@ -0,0 +1,123 @@
+from skills.skill import Skill
+import openai
+import os
+import requests
+from urllib.parse import quote # Python built-in URL encoding function
+
+#This Airtable Skill is tuned to work with our Airtable set up, where we are seaeching a specific column in a specific table, in a specific base. ll three variables need to be set below (Lines 55-59)
+class AirtableSearch(Skill):
+ name = 'airtable_search'
+ description = "A skill that retrieves data from our Airtable notes using a search. Useful for remembering who we talked to about a certain topic."
+ api_keys_required = ['code_reader','skill_saver','documentation_search','text_completion']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ # Initialize a list to keep track of queries tried
+ tried_queries = []
+
+ # Modify the query based on the dependent task output
+ if dependent_task_outputs != "":
+ dependent_task = f"Use the dependent task output below as reference to help craft the correct search query for the provided task above. Dependent task output:{dependent_task_outputs}."
+ else:
+ dependent_task = "."
+
+ # Initialize output
+ output = ''
+
+ while not output:
+ # If there are tried queries, add them to the prompt
+ tried_queries_prompt = f" Do not include search queries we have tried, and instead try synonyms or misspellings. Search queries we have tried: {', '.join(tried_queries)}." if tried_queries else ""
+ print(tried_queries_prompt)
+ query = self.text_completion_tool(f"You are an AI assistant tasked with generating a one word search query based on the following task: {params}. Provide only the search query as a response. {tried_queries_prompt} Take into account output from the previous task:{dependent_task}.\nExample Task: Retrieve data from Airtable notes using the skill 'airtable_search' to find people we have talked to about TED AI.\nExample Query:TED AI\nExample Task:Conduct a search in our Airtable notes to identify investors who have expressed interest in climate.\nExample Query:climate\nTask:{params}\nQuery:")
+
+ # Add the query to the list of tried queries
+ tried_queries.append(query)
+
+ print("\033[90m\033[3m"+"Search query: " +str(query)+"\033[0m")
+
+ # Retrieve the Airtable API key
+ airtable_api_key = self.api_keys['airtable']
+
+ # Set the headers for the API request
+ headers = {
+ "Authorization": f"Bearer {airtable_api_key}",
+ "Content-Type": "application/json"
+ }
+
+
+ # Set base id
+ base_id = ''
+ table_name = ' and end with . Only provide code.:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return "\n\n"+response.choices[0].message['content'].strip()
diff --git a/classic/babyfoxagi/skills/google_jobs_api_search.py b/classic/babyfoxagi/skills/google_jobs_api_search.py
new file mode 100644
index 00000000..dc22d8f0
--- /dev/null
+++ b/classic/babyfoxagi/skills/google_jobs_api_search.py
@@ -0,0 +1,83 @@
+from skills.skill import Skill
+from serpapi import GoogleSearch
+import openai
+from bs4 import BeautifulSoup
+import requests
+import re
+import time
+
+headers = {
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36"
+}
+
+class GoogleJobsAPISearch(Skill):
+ name = 'google_jobs_api_search'
+ description = 'A skill for searching for job listings using the Google Jobs API.'
+ api_keys_required = [['serpapi']]
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ # Modify the query based on the dependent task output
+ if dependent_task_outputs != "":
+ dependent_task = f"Use the dependent task output below as reference to help craft the correct search query for the provided task above. Dependent task output:{dependent_task_outputs}."
+ else:
+ dependent_task = ""
+
+ # Generate the search query
+ query = self.text_completion_tool(f"You are an AI assistant tasked with generating a Google Jobs API search query based on the following task: {params}. If the task looks like a search query, return the identical search query as your response. {dependent_task}\nSearch Query:")
+ print("\033[90m\033[3m" + "Search query: " + str(query) + "\033[0m")
+
+ # Set the search parameters
+ search_params = {
+ "engine": "google_jobs",
+ "q": query,
+ "api_key": self.serpapi_api_key,
+ "num": 3
+ }
+
+ # Perform the job search
+ job_results = GoogleSearch(search_params).get_dict()
+
+ # Simplify the job results
+ simplified_results = self.simplify_job_results(job_results.get('jobs_results', []))
+
+ # Generate a report
+ report = self.text_completion_tool(f"You are an expert analyst combining the results of multiple job searches. Rewrite the following information as one cohesive report without removing any facts. Keep job URL for each. Ignore any reports of not having info, unless all reports say so - in which case explain that the search did not work and suggest other job search queries to try.\n###INFORMATION:{simplified_results}.\n###REPORT:")
+
+ time.sleep(1)
+
+ return report
+
+ def simplify_job_results(self, job_results):
+ simplified_results = []
+ for result in job_results:
+ simplified_result = {
+ "title": result.get("title"),
+ "company_name": result.get("company_name"),
+ "location": result.get("location"),
+ "via": result.get("via"),
+ "description": result.get("description"),
+ "related_links": result.get("related_links"),
+ "extensions": result.get("extensions"),
+ "detected_extensions": result.get("detected_extensions")
+ }
+ simplified_results.append(simplified_result)
+ return simplified_results
+
+ def text_completion_tool(self, prompt: str):
+ messages = [
+ {"role": "user", "content": prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0.2,
+ max_tokens=500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return response.choices[0].message['content'].strip()
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/image_generation.py b/classic/babyfoxagi/skills/image_generation.py
new file mode 100644
index 00000000..37acbfd4
--- /dev/null
+++ b/classic/babyfoxagi/skills/image_generation.py
@@ -0,0 +1,84 @@
+from skills.skill import Skill
+import openai
+import requests
+import os
+from urllib.parse import urlparse
+
+class ImageGeneration(Skill):
+ name = 'image_generation'
+ description = "A drawing tool that uses OpenAI's DALL-E API to generate images."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def download_and_save_image(self, url, folder_path="public/static/images"):
+ if not os.path.exists(folder_path):
+ os.makedirs(folder_path)
+
+ response = requests.get(url)
+
+ # Extract file name from URL
+ parsed_url = urlparse(url)
+ file_name = os.path.basename(parsed_url.path)
+
+ # Save image to folder
+ file_path = os.path.join(folder_path, file_name)
+ with open(file_path, 'wb') as f:
+ f.write(response.content)
+
+ return file_path
+
+ def generate_prompt(self, objective):
+ prompt_generation_messages = [
+ {"role": "system", "content": "You are a helpful assistant specialized in generating creative and descriptive prompts for image generation. Your response is always one sentence with no line breaks. If the input is already detailed, do not change it."},
+ {"role": "user", "content": "Generate a prompt for image creation based on the following objective: Draw a dystopian industrial city"},
+ {"role": "assistant", "content": "Realistic painting of a dystopian industrial city with towering factories, pollution-filled air, and a gloomy sky."},
+ {"role": "user", "content": "Generate a prompt for image creation based on the following objective: Draw interior photography of a cozy corner in a coffee shop, using natural light."},
+ {"role": "assistant", "content": "Interior photography of a cozy corner in a coffee shop, using natural light."},
+ {"role": "user", "content": "Generate a prompt for image creation based on the following objective: Draw an enchanted forest"},
+ {"role": "assistant", "content": "Whimsical painting of an enchanted forest with mythical creatures, vibrant colors, and intricate details."},
+ {"role": "user", "content": "Generate a prompt for image creation based on the following objective: " + objective}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=prompt_generation_messages
+ )
+
+ return response.choices[0].message['content'].strip()
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+ print(f"Objective: {objective}")
+
+ # Generate a creative prompt for DALL-E based on the objective
+ generated_prompt = self.generate_prompt(objective)
+ print(f"generated_prompt: {generated_prompt}")
+
+ # Make API request to generate image based on the generated prompt
+ response = openai.Image.create(
+ prompt=generated_prompt,
+ n=1,
+ size="512x512",
+ response_format="url"
+ )
+
+ # Extract URL of the generated image
+ image_url = response.data[0]['url']
+ print(f"image_url: {image_url}")
+
+ # Download and save the image to your specified folder
+ saved_image_path = self.download_and_save_image(image_url)
+ print(f"saved_image_path: {saved_image_path}")
+
+ # Generate the HTML code with a hard-coded relative path to display the image
+ relative_image_path = os.path.relpath(saved_image_path, start="public")
+ print(f"relative_image_path: {relative_image_path}")
+
+ # The path is hardcoded here based on what you said works
+ html_code = f''
+ print(f"html_code: {html_code}")
+
+ return html_code
diff --git a/classic/babyfoxagi/skills/play_music.py b/classic/babyfoxagi/skills/play_music.py
new file mode 100644
index 00000000..e64d75bd
--- /dev/null
+++ b/classic/babyfoxagi/skills/play_music.py
@@ -0,0 +1,102 @@
+from skills.skill import Skill
+import openai
+import requests
+import os
+import json
+from urllib.parse import urlparse
+
+class PlayMusic(Skill):
+ name = 'play_music'
+ description = "A skill that uses the Deezer API to search for music and play it with an html player."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def download_and_save_image(self, url, folder_path="public/static/images"):
+ if not os.path.exists(folder_path):
+ os.makedirs(folder_path)
+
+ response = requests.get(url)
+
+ # Extract file name from URL
+ parsed_url = urlparse(url)
+ file_name = os.path.basename(parsed_url.path)
+
+ # Save image to folder
+ file_path = os.path.join(folder_path, file_name)
+ with open(file_path, 'wb') as f:
+ f.write(response.content)
+
+ return file_path
+
+ def generate_prompt(self, objective):
+ prompt_generation_messages = [
+ {"role": "system", "content": "You are a helpful assistant specialized in generating a query for Deezer's music API which is a query and search type. Search types are artist, album name, genre, and track name. Both query and search type should have single quotes, and separated by a comma"},
+ {"role": "user", "content": "Play some Eminem"},
+ {"role": "assistant", "content": "'Eminem','artist'"},
+ {"role": "user", "content": "Play tropical house."},
+ {"role": "assistant", "content": "'tropical house','genre'"},
+ {"role": "user", "content": "Play 99 problems"},
+ {"role": "assistant", "content": "'99 problems','track'"},
+ {"role": "user", "content": "Play abbey road"},
+ {"role": "assistant", "content": "'abbey road','album'"},
+ {"role": "user", "content": objective}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=prompt_generation_messages
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+ def deezer_search(self, query, search_type):
+ base_url = "https://api.deezer.com/search"
+
+ params = {"q": f"{search_type}:'{query}'"}
+
+ response = requests.get(base_url, params=params)
+
+ if response.status_code != 200:
+ print("Failed to get data:", response.status_code)
+ return None
+
+ results = json.loads(response.text)
+
+ if not results['data']:
+ print("No results found")
+ return None
+
+ first_result = results['data'][0]
+
+ if search_type == "artist":
+ artist_id = first_result['artist']['id']
+ return f''
+ elif search_type == "album":
+ album_id = first_result['album']['id']
+ return f''
+ elif search_type == "track":
+ track_id = first_result['id']
+ return f''
+ elif search_type == "genre":
+ genre_id = first_result['id']
+ return f''
+ else:
+ print("Unsupported search type")
+ return None
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+ print(f"Objective: {objective}")
+
+ generated_prompt = self.generate_prompt(objective)
+ print(f"generated_prompt: {generated_prompt}")
+
+ query, search_type = [x.strip().strip("'") for x in generated_prompt.split(",")]
+
+ response = self.deezer_search(query, search_type) # Modified this line
+
+ return response
diff --git a/classic/babyfoxagi/skills/pretty_me.py b/classic/babyfoxagi/skills/pretty_me.py
new file mode 100644
index 00000000..cc10b637
--- /dev/null
+++ b/classic/babyfoxagi/skills/pretty_me.py
@@ -0,0 +1,101 @@
+import openai
+import logging
+from skills.skill import Skill
+import os
+
+# A little sloppy and experimental, but it's fun. Here's a demo: https://twitter.com/yoheinakajima/status/1699689836746358866
+
+class PrettyMe(Skill):
+ name = 'pretty_me'
+ description = "A tool to update the current website UI by generating JavaScript that will execute upon load to change the front-end interface of the website it's on. The code response will be directly wrapped in a window.onload function and executed on the front-end. Use for any requests related to updating the UI (background, theme, etc.)"
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ try:
+ if not self.valid:
+ return "API keys not configured properly."
+
+ # Read the contents of your CSS and HTML files
+ css_path = os.path.join("public", "static", "style.css")
+ html_path = os.path.join("templates", "index.html")
+
+ with open(css_path, 'r') as css_file, open(html_path, 'r') as html_file:
+ css_content = css_file.read()
+ html_content = html_file.read()
+
+ # Prepare the prompt with CSS and HTML content
+ task_prompt = f"Generate JavaScript code to execute based on the following user input: {objective} {params}\nCSS Content: {css_content}\nHTML Content: {html_content}\nInstructions: only provide Javascript code that would go between the script tags, but do not provide the script tags.\n### Code:"
+ example_input2 = "make me nature themed."
+
+ example_output2 = '''
+ // Remove body background image and adjust body background color
+ document.body.style.backgroundImage = "none";
+ document.body.style.backgroundColor = "#4CAF50"; // Green color
+
+ // Adjust chat box background color
+ document.querySelector(".chat-box").style.backgroundColor = "#4CAF50"; // Green color
+
+ // Adjust chat messages' background color and bubble tail styles
+ document.querySelectorAll(".bg-blue-200").forEach(function(element) {
+ element.style.backgroundColor = "#357E68"; // Darker green
+ });
+ document.querySelectorAll(".bg-gray-300").forEach(function(element) {
+ element.style.backgroundColor = "#295E4C"; // Darker green
+ element.style.borderLeftColor = "#357E68"; // Border color matching user's bubble
+ });
+
+ // Adjust objectives box background color
+ document.querySelector(".objectives-box").style.backgroundColor = "#4CAF50"; // Green color
+
+ // Adjust task item background color
+ document.querySelectorAll(".task-item").forEach(function(element) {
+ element.style.backgroundColor = "#295E4C"; // Darker green
+ });
+
+ // Adjust task output background color
+ document.querySelectorAll(".task-output").forEach(function(element) {
+ element.style.backgroundColor = "#fffdfd"; // Light gray
+ });
+ '''
+
+# Use the example2 variable in your execute function
+
+
+ messages = [
+ {"role": "user", "content": example_input2},
+ {"role": "assistant", "content": example_output2},
+ {"role": "user", "content": "make my background red."},
+ {"role": "assistant", "content": "document.body.style.backgroundColor = \"red\";\ndocument.body.style.backgroundImage = \"none\";"},
+ {"role": "user", "content": task_prompt}
+ ]
+ print(messages)
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ generated_code = response.choices[0].message['content'].strip()
+
+ # Wrap the generated code with an onload event handler
+ wrapped_code = f'''
+
+ '''
+ return "\n\n" + wrapped_code
+ except Exception as exc:
+ # Log the exception for debugging
+ logging.error(f"Error in PrettyMe skill: {exc}")
+ # Return a user-friendly error message
+ return "An error occurred while processing your request."
diff --git a/classic/babyfoxagi/skills/skill.py b/classic/babyfoxagi/skills/skill.py
new file mode 100644
index 00000000..a291247a
--- /dev/null
+++ b/classic/babyfoxagi/skills/skill.py
@@ -0,0 +1,36 @@
+class Skill:
+ name = 'base skill'
+ description = 'This is the base skill.'
+ api_keys_required = []
+
+ def __init__(self, api_keys, main_loop_function):
+ print(f"Initializing {self.name}")
+ self.api_keys = api_keys
+ self.main_loop_function = main_loop_function
+ missing_keys = self.check_required_keys(api_keys)
+ if missing_keys:
+ print(f"Missing API keys for {self.name}: {missing_keys}")
+ self.valid = False
+ else:
+ self.valid = True
+ for key in self.api_keys_required:
+ if isinstance(key, list):
+ for subkey in key:
+ if subkey in api_keys:
+ setattr(self, f"{subkey}_api_key", api_keys.get(subkey))
+ elif key in api_keys:
+ setattr(self, f"{key}_api_key", api_keys.get(key))
+ print(f"{self.name} initialized successfully")
+
+ def check_required_keys(self, api_keys):
+ missing_keys = []
+ for key in self.api_keys_required:
+ if isinstance(key, list): # If the key is actually a list of alternatives
+ if not any(k in api_keys for k in key): # If none of the alternatives are present
+ missing_keys.append(key) # Add the list of alternatives to the missing keys
+ elif key not in api_keys: # If the key is a single key and it's not present
+ missing_keys.append(key) # Add the key to the missing keys
+ return missing_keys
+
+ def execute(self, params, dependent_task_outputs, objective):
+ raise NotImplementedError('Execute method must be implemented in subclass.')
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/skill_registry.py b/classic/babyfoxagi/skills/skill_registry.py
new file mode 100644
index 00000000..8a145aa2
--- /dev/null
+++ b/classic/babyfoxagi/skills/skill_registry.py
@@ -0,0 +1,107 @@
+import os
+import json
+import openai
+import importlib.util
+import inspect
+from .skill import Skill
+
+class SkillRegistry:
+ def __init__(self, api_keys, main_loop_function, skill_names=None):
+ self.main_loop_function = main_loop_function
+ self.skills = {}
+ skill_files = [f for f in os.listdir('skills') if f.endswith('.py') and f != 'skill.py']
+ for skill_file in skill_files:
+ module_name = skill_file[:-3]
+ if skill_names and module_name not in skill_names:
+ continue
+ module = importlib.import_module(f'skills.{module_name}')
+ for attr_name in dir(module):
+ attr_value = getattr(module, attr_name)
+ if inspect.isclass(attr_value) and issubclass(attr_value, Skill) and attr_value is not Skill:
+ print(f"Attempting to instantiate skill: {attr_name}")
+
+ try:
+ skill = attr_value(api_keys, self.main_loop_function)
+ if skill.valid:
+ self.skills[skill.name] = skill
+ except Exception as e:
+ print(f"Error while instantiating skill '{attr_name}': {e}")
+ skill = attr_value(api_keys, self.main_loop_function)
+ # Print the names and descriptions of all loaded skills
+ skill_info = "\n".join([f"{skill_name}: {skill.description}" for skill_name, skill in self.skills.items()])
+ print(skill_info)
+
+ def load_all_skills(self):
+ skills_dir = os.path.dirname(__file__)
+ for filename in os.listdir(skills_dir):
+ if filename.endswith(".py") and filename not in ["__init__.py", "skill.py", "skill_registry.py"]:
+ skill_name = filename[:-3] # Remove .py extension
+ self.load_skill(skill_name)
+
+ def load_specific_skills(self, skill_names):
+ for skill_name in skill_names:
+ self.load_skill(skill_name)
+
+ def load_skill(self, skill_name):
+ skills_dir = os.path.dirname(__file__)
+ filename = f"{skill_name}.py"
+ if os.path.isfile(os.path.join(skills_dir, filename)):
+ spec = importlib.util.spec_from_file_location(skill_name, os.path.join(skills_dir, filename))
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ for item_name in dir(module):
+ item = getattr(module, item_name)
+ if isinstance(item, type) and issubclass(item, Skill) and item is not Skill:
+ skill_instance = item(self.api_keys)
+ self.skills[skill_instance.name] = skill_instance
+
+ def get_skill(self, skill_name):
+ skill = self.skills.get(skill_name)
+ if skill is None:
+ raise Exception(
+ f"Skill '{skill_name}' not found. Please make sure the skill is loaded and all required API keys are set.")
+ return skill
+
+ def get_all_skills(self):
+ return self.skills
+
+
+ def reflect_skills(self, objective, task_list, task_outputs, skill_descriptions):
+ prompt = (
+ f"You are an expert task manager. Reflect on the objective, entire task list, and the corresponding outputs. "
+ f"Determine whether the available skills were sufficient, and if not, identify and describe new skills that are needed. "
+ f"Provide your response as a JSON array. "
+ f"OBJECTIVE: {objective}."
+ f"AVAILABLE SKILLS: {skill_descriptions}."
+ f"\n###Here is the current task list: {json.dumps(task_list)}"
+ f"\n###Here is the task outputs: {json.dumps(task_outputs)}."
+ f"Missing skills:"
+ )
+ print("\033[90m\033[3m" + "\nReflecting on skills used in task list...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are an AI specializing in reflecting on skills used in tasks and identifying missing skills. You will provide a JSON array as your response."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ skills_analysis = json.loads(result)
+ print(skills_analysis)
+ except Exception as error:
+ print(error)
+
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/skill_saver.py b/classic/babyfoxagi/skills/skill_saver.py
new file mode 100644
index 00000000..9c879784
--- /dev/null
+++ b/classic/babyfoxagi/skills/skill_saver.py
@@ -0,0 +1,58 @@
+from skills.skill import Skill
+import os
+import openai
+
+class SkillSaver(Skill):
+ name = 'skill_saver'
+ description = "A skill that saves code written in a previous step into a file within the skills folder. Not for writing code."
+ api_keys_required = []
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ task_prompt = f"Extract the code and only the code from the dependent task output here: {dependent_task_outputs} \n###\nCODE:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ code = response.choices[0].message['content'].strip()
+ task_prompt = f"Come up with a file name (eg. 'get_weather.py') for the following skill:{code}\n###\nFILE_NAME:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ file_name = response.choices[0].message['content'].strip()
+ file_path = os.path.join('skills',file_name)
+
+ try:
+ with open(file_path, 'w') as file:
+ file.write(code)
+ print(f"Code saved successfully: {file_name}")
+ except:
+ print("Error saving code.")
+
+ return None
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/startup_analysis.py b/classic/babyfoxagi/skills/startup_analysis.py
new file mode 100644
index 00000000..f9f5eeb4
--- /dev/null
+++ b/classic/babyfoxagi/skills/startup_analysis.py
@@ -0,0 +1,105 @@
+from skills.skill import Skill
+import openai
+import json
+
+class StartupAnalysis(Skill):
+ name = 'startup_analysis'
+ description = "A tool specialized in providing a detailed analysis of startups using OpenAI's text completion API. Analyzes parameters like customers, ICP, pain points, competitors, etc."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ completion = openai.ChatCompletion.create(
+ model="gpt-4",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a great AI analyst specialized in writing VC investment memos. Write one paragraph each in the third person on customers, ICP, pain points, alternate solutions, competitors, potential partners, key incumbents, history of innovation in the industry, key risks, legal considerations, important figures or influencers, and other recent trends in the space. The user will provide the startup description."
+ },
+ {
+ "role": "user",
+ "content": params
+ # User provides a detailed description of their startup
+ }
+ ],
+ functions=[
+ {
+ "name": "analyze_startup",
+ "description": "Analyze the startup based on various parameters",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "customers": {
+ "type": "string",
+ "description": "Who are the startup's primary customers. Describe in detail in the third person."
+ },
+ "ICP": {
+ "type": "string",
+ "description": "What is the startup's Ideal Customer Profile. Describe in detail in the third person."
+ },
+ "pain_points": {
+ "type": "string",
+ "description": "What are the pain points the startup is trying to solve. Describe in detail in the third person."
+ },
+ "alternate_solutions": {
+ "type": "string",
+ "description": "What are the alternate solutions available in the market. Describe in detail in the third person."
+ },
+ "competitors": {
+ "type": "string",
+ "description": "Who are the startup's main competitors. Describe in detail in the third person."
+ },
+ "potential_partners": {
+ "type": "string",
+ "description": "Who could be the startup's potential partners. Describe in detail in the third person."
+ },
+ "key_incumbents": {
+ "type": "string",
+ "description": "Key incumbents in the industry. Describe in detail."
+ },
+ "history_of_innovation": {
+ "type": "string",
+ "description": "History of innovation in the startup's industry. Describe in detail in the third person."
+ },
+ "key_risks": {
+ "type": "string",
+ "description": "What are the key risks involved in the startup. Describe in detail in the third person."
+ },
+ "legal_considerations": {
+ "type": "string",
+ "description": "Any legal considerations that the startup should be aware of"
+ },
+ "important_figures": {
+ "type": "string",
+ "description": "Important figures or influencers in the industry. Describe in detail in the third person."
+ },
+ "recent_trends": {
+ "type": "string",
+ "description": "What are the recent trends in the startup's industry. Describe in detail."
+ }
+ },
+ "required": [
+ "customers", "ICP", "pain_points", "alternate_solutions",
+ "competitors", "potential_partners", "key_incumbents",
+ "history_of_innovation", "key_risks", "legal_considerations",
+ "important_figures", "recent_trends"
+ ],
+ },
+ },
+ ],
+ function_call={"name": "analyze_startup"}
+ )
+
+ response_data = completion.choices[0]['message']['function_call']['arguments']
+
+ html_content = ""
+ for key, value in json.loads(response_data).items():
+ html_content += f"{key.capitalize()}: {value}\n"
+
+
+ return html_content
diff --git a/classic/babyfoxagi/skills/text_completion.py b/classic/babyfoxagi/skills/text_completion.py
new file mode 100644
index 00000000..89a6c451
--- /dev/null
+++ b/classic/babyfoxagi/skills/text_completion.py
@@ -0,0 +1,31 @@
+from skills.skill import Skill
+import openai
+
+class TextCompletion(Skill):
+ name = 'text_completion'
+ description = "A tool that uses OpenAI's text completion API to generate, summarize, and/or analyze text and code."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ task_prompt = f"Complete your assigned task based on the objective and only based on information provided in the dependent task output, if provided. \n###\nYour objective: {objective}. \n###\nYour task: {params} \n###\nDependent tasks output: {dependent_task_outputs} \n###\nYour task: {params}\n###\nRESPONSE:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return "\n\n"+response.choices[0].message['content'].strip()
diff --git a/classic/babyfoxagi/skills/web_search.py b/classic/babyfoxagi/skills/web_search.py
new file mode 100644
index 00000000..74978730
--- /dev/null
+++ b/classic/babyfoxagi/skills/web_search.py
@@ -0,0 +1,155 @@
+from skills.skill import Skill
+from serpapi import GoogleSearch
+import openai
+from bs4 import BeautifulSoup
+import requests
+import re
+import time
+
+headers = {
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36"
+}
+
+class WebSearch(Skill):
+ name = 'web_search'
+ description = 'A tool that performs web searches.'
+ api_keys_required = [['openai'],['serpapi']]
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ # Your function goes here
+
+
+ # Modify the query based on the dependent task output
+ if dependent_task_outputs != "":
+ dependent_task = f"Use the dependent task output below as reference to help craft the correct search query for the provided task above. Dependent task output:{dependent_task_outputs}."
+ else:
+ dependent_task = "."
+ query = self.text_completion_tool("You are an AI assistant tasked with generating a short and simple Google search query based on the following task: "+params+"."+dependent_task + "\nExample Task: Perform a web search to find reputable sources of news in the field of AI for today's date.\nExample Query:AI News\nExample Task:Perform a search for Yohei Nakajima at Untapped Capital\nExample Query:Yohei Nakajima Untapped Capital\nTask:"+params+"\nQuery:")
+ print("\033[90m\033[3m"+"Search query: " +str(query)+"\033[0m")
+ # Set the search parameters
+
+ search_params = {
+ "engine": "google",
+ "q": query,
+ "api_key": self.serpapi_api_key,
+ "num": 3
+ }
+ # Perform the web search
+ search_results = GoogleSearch(search_params).get_dict()
+
+ # Simplify the search results
+ search_results = self.simplify_search_results(search_results.get('organic_results', []))
+ print("\033[90m\033[3mCompleted search. Now scraping results.\n\033[0m")
+
+ # Store the results from web scraping
+ results = ""
+ for result in search_results:
+ url = result.get('link')
+ print("\033[90m\033[3m" + "Scraping: "+url+"" + "...\033[0m")
+ content = self.web_scrape_tool({"url": url, "task": params,"objective":objective})
+ results += str(content) + ". "
+ print("\033[90m\033[3m"+str(results[0:100])[0:100]+"...\033[0m")
+ # Process the results and generate a report
+ results = self.text_completion_tool(f"You are an expert analyst combining the results of multiple web scrapes. Rewrite the following information as one cohesive report without removing any facts. Ignore any reports of not having info, unless all reports say so - in which case explain that the search did not work and suggest other web search queries to try. \n###INFORMATION:{results}.\n###REPORT:")
+ time.sleep(1)
+ print("DONE!!!")
+ return results
+
+ def simplify_search_results(self, search_results):
+ simplified_results = []
+ for result in search_results:
+ simplified_result = {
+ "position": result.get("position"),
+ "title": result.get("title"),
+ "link": result.get("link"),
+ "snippet": result.get("snippet")
+ }
+ simplified_results.append(simplified_result)
+ return simplified_results
+
+
+ def text_completion_tool(self, prompt: str):
+ messages = [
+ {"role": "user", "content": prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0,
+ max_tokens=2000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+ def web_scrape_tool(self, params):
+ content = self.fetch_url_content(params['url'])
+ if content is None:
+ return None
+
+ text = self.extract_text(content)
+ print("\033[90m\033[3m"+"Scrape completed. Length:" +str(len(text))+".Now extracting relevant info..."+"...\033[0m")
+ info = self.extract_relevant_info(params['objective'], text[0:11000], params['task'])
+ links = self.extract_links(content)
+ #result = f"{info} URLs: {', '.join(links)}"
+ result = info
+
+ return result
+
+ def fetch_url_content(self,url: str):
+ try:
+ response = requests.get(url, headers=headers, timeout=10)
+ response.raise_for_status()
+ return response.content
+ except requests.exceptions.RequestException as e:
+ print(f"Error while fetching the URL: {e}")
+ return ""
+
+ def extract_links(self,content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ links = [link.get('href') for link in soup.findAll('a', attrs={'href': re.compile("^https?://")})]
+ return links
+
+ def extract_text(self,content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ text = soup.get_text(strip=True)
+ return text
+
+ def extract_relevant_info(self, objective, large_string, task):
+ chunk_size = 12000
+ overlap = 500
+ notes = ""
+
+ if len(large_string) == 0:
+ print("error scraping")
+ return "Error scraping."
+
+ for i in range(0, len(large_string), chunk_size - overlap):
+
+ print("\033[90m\033[3m"+"Reading chunk..."+"\033[0m")
+ chunk = large_string[i:i + chunk_size]
+
+ messages = [
+ {"role": "system", "content": f"You are an AI assistant."},
+ {"role": "user", "content": f"You are an expert AI research assistant tasked with creating or updating the current notes. If the current note is empty, start a current-notes section by exracting relevant data to the task and objective from the chunk of text to analyze. If there is a current note, add new relevant info frol the chunk of text to analyze. Make sure the new or combined notes is comprehensive and well written. Here's the current chunk of text to analyze: {chunk}. ### Here is the current task: {task}.### For context, here is the objective: {objective}.### Here is the data we've extraced so far that you need to update: {notes}.### new-or-updated-note:"}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ max_tokens=2000,
+ n=1,
+ stop="###",
+ temperature=0.7,
+ )
+
+ notes += response.choices[0].message['content'].strip()+". ";
+ time.sleep(1)
+
+ return notes
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/__init__.py b/classic/babyfoxagi/tasks/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/classic/babyfoxagi/tasks/__pycache__/__init__.cpython-38.pyc b/classic/babyfoxagi/tasks/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 00000000..4369fe8c
Binary files /dev/null and b/classic/babyfoxagi/tasks/__pycache__/__init__.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-310.pyc b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-310.pyc
new file mode 100644
index 00000000..255f1809
Binary files /dev/null and b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-38.pyc b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-38.pyc
new file mode 100644
index 00000000..8ffd4ee9
Binary files /dev/null and b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json b/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json
new file mode 100644
index 00000000..855cd34d
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Create new example objective for researching waterproof kid shoes.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Read the contents of example1.json in the example_objectives folder using the code_reader skill.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Use text_completion to generate a new example objective and task list as JSON based on the extracted information from example1.json.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created example objective and task list as JSON using the objective_saver skill.",
+ "skill": "objective_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/babyfoxagi/tasks/example_objectives/example1.json b/classic/babyfoxagi/tasks/example_objectives/example1.json
new file mode 100644
index 00000000..64a39aa5
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example1.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Create a new skill that writes a poem based on an input.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Read the code in text_completion.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a new skill that uses the concepts from text_completion.py to generate a poem based on user input.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created skill using the skill_saver skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/example_objectives/example2.json b/classic/babyfoxagi/tasks/example_objectives/example2.json
new file mode 100644
index 00000000..889a8bc1
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example2.json
@@ -0,0 +1,33 @@
+[{
+ "objective": "Create a new skill that looks up the weather based on a location input.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Search code examples for free weather APIs to gather information on how to retrieve weather data based on a location input.",
+ "skill": "documentation_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Read the code in text_completion.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Write a new skill that combines the concepts from text_completion.py and the code examples for free weather APIs to implement weather lookup based on a location input.",
+ "skill": "text_completion",
+ "dependent_task_ids": [2, 1],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Save the newly created skill using the skill_saver skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [3],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/example_objectives/example3.json b/classic/babyfoxagi/tasks/example_objectives/example3.json
new file mode 100644
index 00000000..9fdcfdb5
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example3.json
@@ -0,0 +1,40 @@
+[{
+ "objective": "Research untapped.vc",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Conduct a web search on 'untapped.vc' to gather information about the company, its investments, and its impact in the startup ecosystem.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Based on the results from the first web search, perform a follow-up web search to explore specific areas of interest or investment strategies of 'untapped.vc'.",
+ "skill": "web_search",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Use text_completion to summarize the findings from the initial web search on 'untapped.vc' and provide key insights.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Use text_completion to summarize the findings from the follow-up web search and highlight any additional information or insights.",
+ "skill": "text_completion",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ },
+ {
+ "id": 5,
+ "task": "Combine the summaries from the initial and follow-up web searches to provide a comprehensive overview of 'untapped.vc' and its activities.",
+ "skill": "text_completion",
+ "dependent_task_ids": [3, 4],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/example_objectives/example5.json b/classic/babyfoxagi/tasks/example_objectives/example5.json
new file mode 100644
index 00000000..ff779161
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example5.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Based on skill_saver.py, write a new skill called objective_saver.py which saves a new example_objective.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Look up the code in skill_saver.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a new skill called objective_saver.py that saves a new example_objective based on the concepts from skill_saver.py (use text_completion).",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created example_objective using the skill_saver.py skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/babyfoxagi/tasks/example_objectives/example6.json b/classic/babyfoxagi/tasks/example_objectives/example6.json
new file mode 100644
index 00000000..c823c240
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example6.json
@@ -0,0 +1,19 @@
+[{
+ "objective": "Create new skill for writing a poem called poem_saver, then use the poem_writer skill to write a poem about AI.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Create and save a new skill for writing a poem based on an input.",
+ "skill": "call_babyagi",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a poem about AI.",
+ "skill": "poem_writer",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json b/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json
new file mode 100644
index 00000000..4a5fba22
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json
@@ -0,0 +1,42 @@
+[
+
+{
+ "objective": "Research waterproof kid shoes to find the best options available in the market.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Search online for popular brands of waterproof kid shoes.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Read customer reviews and ratings for different waterproof kid shoes.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Compare the features and prices of waterproof kid shoes from different brands.",
+ "skill": "text_completion",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Make a list of the top 5 waterproof kid shoes based on research findings.",
+ "skill": "text_completion",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 5,
+ "task": "Finalize the selection of the best waterproof kid shoes based on research and recommendations.",
+ "skill": "text_completion",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/task_registry.py b/classic/babyfoxagi/tasks/task_registry.py
new file mode 100644
index 00000000..a06ac8c3
--- /dev/null
+++ b/classic/babyfoxagi/tasks/task_registry.py
@@ -0,0 +1,514 @@
+import openai
+import json
+import threading
+import os
+import numpy as np
+from datetime import datetime
+from collections import defaultdict
+
+class TaskRegistry:
+ def __init__(self):
+ self.tasks = []
+ # Initialize the lock
+ self.lock = threading.Lock()
+ objectives_file_path = "tasks/example_objectives"
+ self.example_loader = ExampleObjectivesLoader(objectives_file_path)
+
+ def load_example_objectives(self, user_objective):
+ return self.example_loader.load_example_objectives(user_objective)
+
+
+ def create_tasklist(self, objective, skill_descriptions):
+ #reflect on objective
+ notes = self.reflect_on_objective(objective,skill_descriptions)
+ #load most relevant object and tasklist from objectives_examples.json
+ example_objective, example_tasklist, example_reflection = self.load_example_objectives(objective)
+
+ prompt = (
+ f"You are an expert task list creation AI tasked with creating a list of tasks as a JSON array, considering the ultimate objective of your team: {objective}. "
+ f"Create a very short task list based on the objective, the final output of the last task will be provided back to the user. Limit tasks types to those that can be completed with the available skills listed below. Task description should be detailed.###"
+ f"AVAILABLE SKILLS: {skill_descriptions}.###"
+ f"RULES:"
+ f"Do not use skills that are not listed."
+ f"Always provide an ID to each task."
+ f"Always include one skill."
+ f"The final task should always output the final result of the overall objective."
+ f"dependent_task_ids should always be an empty array, or an array of numbers representing the task ID it should pull results from."
+ f"Make sure all task IDs are in chronological order.###\n"
+ f"Helpful Notes as guidance:{notes}###\n"
+ f"EXAMPLE OBJECTIVE={json.dumps(example_objective)}"
+ f"TASK LIST={json.dumps(example_tasklist)}"
+ f"OBJECTIVE={objective}"
+ f"TASK LIST="
+ )
+ #print(prompt)
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=2500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ task_list = json.loads(result)
+ #print(task_list)
+ self.tasks = task_list
+ except Exception as error:
+ print(error)
+
+
+ def reflect_on_objective(self, objective, skill_descriptions):
+ #load most relevant object and tasklist from objectives_examples.json
+ example_objective, example_tasklist, example_reflection = self.load_example_objectives(objective)
+
+ prompt = (
+ f"You are an Ai specializing in generating helpful thoughts and ideas on tackling an objective, and your task is to think about how to tackle this objective: {objective}. "
+ f"These are the skills available to you: {skill_descriptions}.###"
+ f"Think about what tools and information you need to handle this objective, and which of the available skills would be most helpful to you and writea descriptive note to pass onto a task creation AI."
+ f"Consider the following example objective, tasklist, and reflection as a sample."
+ f"###EXAMPLE OBJECTIVE:{example_objective}."
+ f"###EXAMPLE TASKLIST:{example_tasklist}."
+ f"###REFLECTION FROM EXAMPLE:{example_reflection}."
+ f"###THE AI AGENT'S OBJECTIVE:{example_reflection}."
+ f"###INSTRUCTION: please provide helpful notes for the task creation agent specific to this objective."
+ )
+ #print(prompt)
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": f"You are an Ai specializing in generating helpful thoughts and ideas on tackling an objective, and your task is to think about how to tackle this objective: {objective}. "
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=250,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print(result)
+ return result
+
+
+ def execute_task(self, i, task, skill_registry, task_outputs, objective):
+ p_nexttask="\033[92m\033[1m"+"\n*****NEXT TASK ID:"+str(task['id'])+"*****\n"+"\033[0m\033[0m"
+ p_nexttask += f"\033[ EExecuting task {task.get('id')}: {task.get('task')}) [{task.get('skill')}]\033[)"
+ print(p_nexttask)
+ # Retrieve the skill from the registry
+ skill = skill_registry.get_skill(task['skill'])
+ # Get the outputs of the dependent tasks
+ dependent_task_outputs = {dep: task_outputs[dep]["output"] for dep in task['dependent_task_ids']} if 'dependent_task_ids' in task else {}
+ # Execute the skill
+ # print("execute:"+str([task['task'], dependent_task_outputs, objective]))
+ task_output = skill.execute(task['task'], dependent_task_outputs, objective)
+ print("\033[93m\033[1m"+"\nTask Output (ID:"+str(task['id'])+"):"+"\033[0m\033[0m")
+ print("TASK: "+str(task["task"]))
+ print("OUTPUT: "+str(task_output))
+ return i, task_output
+
+
+ def reorder_tasks(self):
+ self.tasks= sorted(self.tasks, key=lambda task: task['id'])
+
+
+
+ def add_task(self, task, after_task_id):
+ # Get the task ids
+ task_ids = [t["id"] for t in self.tasks]
+
+ # Get the index of the task id to add the new task after
+ insert_index = task_ids.index(after_task_id) + 1 if after_task_id in task_ids else len(task_ids)
+
+ # Insert the new task
+ self.tasks.insert(insert_index, task)
+ self.reorder_tasks()
+
+
+ def get_tasks(self):
+ return self.tasks
+
+ def update_tasks(self, task_update):
+ for task in self.tasks:
+ if task['id'] == task_update['id']:
+ task.update(task_update)
+ self.reorder_tasks()
+
+
+ def reflect_on_output(self, task_output, skill_descriptions):
+ with self.lock:
+ example = [
+ [
+ {"id": 3, "task": "New task 1 description", "skill": "text_completion_skill",
+ "dependent_task_ids": [], "status": "complete"},
+ {"id": 4, "task": "New task 2 description", "skill": "text_completion_skill",
+ "dependent_task_ids": [], "status": "incomplete"}
+ ],
+ [2, 3],
+ {"id": 5, "task": "Complete the objective and provide a final report",
+ "skill": "text_completion_skill", "dependent_task_ids": [1, 2, 3, 4], "status": "incomplete"}
+ ]
+
+ prompt = (
+ f"You are an expert task manager, review the task output to decide whether any new tasks need to be added, or whether any tasks need to be updated."
+ f"As you add a new task, see if there are any tasks that need to be updated (such as updating dependencies)."
+ f"Use the current task list as reference."
+ f"Do not add duplicate tasks to those in the current task list."
+ f"Only provide JSON as your response without further comments."
+ f"Every new and updated task must include all variables, even they are empty array."
+ f"Dependent IDs must be smaller than the ID of the task."
+ f"New tasks IDs should be no larger than the last task ID."
+ f"Always select at least one skill."
+ f"Task IDs should be unique and in chronological order." f"Do not change the status of complete tasks."
+ f"Only add skills from the AVAILABLE SKILLS, using the exact same spelling."
+ f"Provide your array as a JSON array with double quotes. The first object is new tasks to add as a JSON array, the second array lists the ID numbers where the new tasks should be added after (number of ID numbers matches array), and the third object provides the tasks that need to be updated."
+ f"Make sure to keep dependent_task_ids key, even if an empty array."
+ f"AVAILABLE SKILLS: {skill_descriptions}.###"
+ f"\n###Here is the last task output: {task_output}"
+ f"\n###Here is the current task list: {self.tasks}"
+ f"\n###EXAMPLE OUTPUT FORMAT = {json.dumps(example)}"
+ f"\n###OUTPUT = "
+ )
+ print("\033[90m\033[3m" + "\nReflecting on task output to generate new tasks if necessary...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k-0613",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0.7,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print("\n#" + str(result))
+
+ # Check if the returned result has the expected structure
+ if isinstance(result, str):
+ try:
+ task_list = json.loads(result)
+ print("####task_list in function")
+
+ print(task_list)
+ print("####task_list split in function")
+ print(task_list[0], task_list[1], task_list[2])
+ return task_list[0], task_list[1], task_list[2]
+ except Exception as error:
+ print(error)
+
+ else:
+ raise ValueError("Invalid task list structure in the output")
+
+ def get_tasks(self):
+ """
+ Returns the current list of tasks.
+
+ Returns:
+ list: the list of tasks.
+ """
+ return self.tasks
+
+ def get_task(self, task_id):
+ """
+ Returns a task given its task_id.
+
+ Parameters:
+ task_id : int
+ The unique ID of the task.
+
+ Returns:
+ dict
+ The task that matches the task_id.
+ """
+ matching_tasks = [task for task in self.tasks if task["id"] == task_id]
+
+ if matching_tasks:
+ return matching_tasks[0]
+ else:
+ print(f"No task found with id {task_id}")
+ return None
+
+ def print_tasklist(self, tasks):
+ p_tasklist="\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m"
+ for t in tasks:
+ dependent_task_ids = t.get('dependent_task_ids', [])
+ dependent_task = ""
+ if dependent_task_ids:
+ dependent_task = f"\033[31m\033[0m"
+ status_color = "\033[32m" if t.get('status') == "completed" else "\033[31m"
+ p_tasklist+= f"\033[1m{t.get('id')}\033[0m: {t.get('task')} {status_color}[{t.get('status')}]\033[0m \033[93m[{t.get('skill')}] {dependent_task}\033[0m\n"
+ print(p_tasklist)
+
+
+
+ def reflect_tasklist(self, objective, task_list, task_outputs, skill_descriptions):
+ prompt = (
+ f"You are an expert task manager. Reflect on the objective, entire task list, and the corresponding outputs to generate a better task list for the objective."
+ f"Do not included 'results', and change every status to 'incomplete'."
+ f"Only provide JSON as your response without further comments. "
+ f"Use the current task list as reference. "
+ f"Always make at least one change to the current task list "
+ f"OBJECTIVE: {objective}."
+ f"AVAILABLE SKILLS: {skill_descriptions}."
+ f"\n###Here is the current task list: {json.dumps(task_list)}"
+ f"\n###Here is the task outputs: {json.dumps(task_outputs)}"
+ f"\n###IMPROVED TASKLIST = "
+ )
+ print("\033[90m\033[3m" + "\nReflecting on entire task list...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are an AI specializing in reflecting on task lists and improving them. You will never simply return the provided task list, but always improve on it."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ improved_task_list = json.loads(result)
+ # Formatting improved_task_list to your desired format
+ formatted_improved_task_list = [{
+ "objective": objective,
+ "examples": improved_task_list,
+ "date": datetime.now().strftime("%Y-%m-%d")
+ }]
+ with open(f'tasks/example_objectives/improved_{datetime.now().strftime("%Y%m%d%H%M%S")}.json', 'w') as f:
+ json.dump(formatted_improved_task_list, f)
+ print(f"IMPROVED TASK LIST:{formatted_improved_task_list}")
+ except Exception as error:
+ print(error)
+
+ def reflect_on_result(self, objective, task_list, task_outputs, skill_descriptions):
+ prompt = (
+ f"You are an expert AI specializing in analyzing yourself, an autonomous agent that combines multiple LLM calls. Reflect on the objective, entire task list, and the corresponding outputs and provide an analysis of the performance of yourself and how you could have performed better."
+ f"\n###OBJECTIVE: {objective}."
+ f"\n###AVAILABLE SKILLS: {skill_descriptions}."
+ f"\n###TASK LIST: {json.dumps(task_list)}"
+ f"\n###TASK OUTPUTS: {json.dumps(task_outputs)}"
+ f"\n###ANALYSIS:"
+ )
+ print("\033[90m\033[3m" + "\nReflecting on result...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are an expert AI specializing in analyzing yourself, an autonomous agent that combines multiple LLM calls. Reflect on the objective, entire task list, and the corresponding outputs and provide an analysis of the performance of yourself and how you could have performed better."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=2000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ print(result)
+ return result
+ except Exception as error:
+ print(error)
+
+
+ def reflect_on_final(self, objective, task_list, task_outputs, skill_descriptions):
+ print("here!")
+ system_content_result = "You are an expert AI specializing in analyzing yourself, an autonomous agent that combines multiple LLM calls. Reflect on the objective, entire task list, and the corresponding outputs and provide an analysis of the performance of yourself and how you could have performed better."
+ role_content_result = (
+ f"You are an expert AI specializing in analyzing yourself, an autonomous agent that combines multiple LLM calls. Reflect on the objective, entire task list, and the corresponding outputs and provide an analysis of the performance of yourself and how you could have performed better."
+ f"\n###OBJECTIVE: {objective}."
+ f"\n###AVAILABLE SKILLS: {skill_descriptions}."
+ f"\n###TASK LIST: {json.dumps(task_list)}"
+ f"\n###TASK OUTPUTS: {json.dumps(task_outputs)}"
+ f"\n###ANALYSIS:"
+ )
+ print("\033[90m\033[3m" + "\nReflecting on result...\n" + "\033[0m")
+ response = self.chatcompletion(role_content_result, system_content_result,500)
+ # Extract the content of the assistant's response and parse it as JSON
+ simple_reflection = response["choices"][0]["message"]["content"]
+ try:
+ print(simple_reflection)
+ except Exception as error:
+ print(error)
+
+ system_content_task = "You are an AI specializing in reflecting on task lists and improving them. You will never simply return the provided task list, but always improve on it."
+ role_content_task = (
+ f"You are an expert task manager. Reflect on the objective, entire task list, and the corresponding outputs to generate a better task list for the objective."
+ f"Do not included 'results', and change every status to 'incomplete'."
+ f"Only provide JSON as your response without further comments. "
+ f"Use the current task list as reference. "
+ f"Always make at least one change to the current task list "
+ f"OBJECTIVE: {objective}."
+ f"AVAILABLE SKILLS: {skill_descriptions}."
+ f"SIMPLE REFLECTION: {simple_reflection}."
+ f"\n###Here is the current task list: {json.dumps(task_list)}"
+ f"\n###Here is the task outputs: {json.dumps(task_outputs)}"
+ f"\n###IMPROVED TASKLIST = "
+ )
+ print("\033[90m\033[3m" + "\nReflecting on entire task list...\n" + "\033[0m")
+ response = self.chatcompletion(role_content_task, system_content_task,4000)
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print(result)
+ try:
+ improved_task_list = json.loads(result)
+ # Formatting improved_task_list to your desired format
+ formatted_improved_task_list = [{
+ "objective": objective,
+ "examples": improved_task_list,
+ "date": datetime.now().strftime("%Y-%m-%d"),
+ "reflection":simple_reflection
+ }]
+ with open(f'tasks/example_objectives/improved_{datetime.now().strftime("%Y%m%d%H%M%S")}.json', 'w') as f:
+ json.dump(formatted_improved_task_list, f)
+ print(f"IMPROVED TASK LIST:{formatted_improved_task_list}")
+ except Exception as error:
+ print(error)
+
+
+
+ def chatcompletion(self, role_content, system_content, max_tokens):
+ return openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": system_content
+ },
+ {
+ "role": "user",
+ "content": role_content
+ }
+ ],
+ temperature=0,
+ max_tokens=max_tokens,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+
+from datetime import datetime
+
+class ExampleObjectivesLoader:
+ def __init__(self, objectives_folder_path, decay_factor=0.01):
+ self.objectives_folder_path = objectives_folder_path
+ self.decay_factor = decay_factor
+ self.objectives_examples = [] # Initialize as an empty list
+
+ def load_objectives_examples(self):
+ objectives_dict = defaultdict(dict)
+
+ for filename in os.listdir(self.objectives_folder_path):
+ file_path = os.path.join(self.objectives_folder_path, filename)
+ with open(file_path, 'r') as file:
+ objectives = json.load(file)
+
+ for objective in objectives:
+ key = objective['objective']
+ date = objective.get('date', None)
+
+ if date is not None:
+ date = datetime.strptime(date, '%Y-%m-%d')
+
+ if key not in objectives_dict or (date and datetime.strptime(objectives_dict[key]['date'], "%Y-%m-%d") < date):
+ objectives_dict[key] = objective
+
+ self.objectives_examples = list(objectives_dict.values())
+
+ def find_most_relevant_objective(self, user_input):
+ user_input_embedding = self.get_embedding(user_input, model='text-embedding-ada-002')
+ most_relevant_objective = max(
+ self.objectives_examples,
+ key=lambda pair: self.cosine_similarity(pair['objective'], user_input_embedding) * self.get_decay(pair)
+ )
+ return most_relevant_objective['objective'], most_relevant_objective['examples'], most_relevant_objective.get('reflection', '')
+
+ def get_decay(self, objective):
+ date = objective.get('date', None)
+ if date is not None:
+ date = datetime.strptime(date, '%Y-%m-%d')
+ days_passed = (datetime.now() - date).days
+ else:
+ # if there's no date, assume a large number of days passed
+ days_passed = 365 * 10 # 10 years
+
+ decay = np.exp(-self.decay_factor * days_passed)
+ return decay
+
+ def get_embedding(self, text, model='text-embedding-ada-002'):
+ response = openai.Embedding.create(input=[text], model=model)
+ embedding = response['data'][0]['embedding']
+ return embedding
+
+ def cosine_similarity(self, objective, embedding):
+ max_similarity = float('-inf')
+ objective_embedding = self.get_embedding(objective, model='text-embedding-ada-002')
+ similarity = self.calculate_similarity(objective_embedding, embedding)
+ max_similarity = max(max_similarity, similarity)
+ return max_similarity
+
+ def calculate_similarity(self, embedding1, embedding2):
+ embedding1 = np.array(embedding1, dtype=np.float32)
+ embedding2 = np.array(embedding2, dtype=np.float32)
+ similarity = np.dot(embedding1, embedding2) / (np.linalg.norm(embedding1) * np.linalg.norm(embedding2))
+ return similarity
+
+ def load_example_objectives(self, user_objective):
+ self.load_objectives_examples()
+ most_relevant_objective, most_relevant_tasklist, most_relevant_reflection = self.find_most_relevant_objective(user_objective)
+ example_objective = most_relevant_objective
+ example_tasklist = most_relevant_tasklist
+ example_reflection = most_relevant_reflection
+ return example_objective, example_tasklist, example_reflection
diff --git a/classic/babyfoxagi/templates/index.html b/classic/babyfoxagi/templates/index.html
new file mode 100644
index 00000000..160e370c
--- /dev/null
+++ b/classic/babyfoxagi/templates/index.html
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+ AI Chat Assistant
+
+
+
+
+
+
+
+
+
+
+
+# الهدف
+
+هذا البرنامج يعتبر مثال تطبيقي لنظام إدارة مهام يعمل بواسطة الذكاء الاصطناعي. يستخدم النظام OpenAI و Chroma DB لإنشاء وترتيب المهام حسب الأولوية و ثم تنفيذها. الفكرة الرئيسية هي إنشاء مهام Tasks جديدة بناءً على هدف محدد مسبقاً بمساعدة الذكاء الاصطناعي -تحديداً، قدرات المعالجة اللغوية التي تقدمها النماذج التوليدية المدربة مسبقاً GPTs- من OpanAI وتخزين هذه المهام و نتائجها في قاعدة بيانات Chroma لاسترجاعها لاحقاً حسب السياق. هذه نسخة مختصرة من المقترح الأصلي [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023).
+
+هذا الملف (README) سوف يغطي:
+
+- [كيف يعمل البرنامج](#how-it-works)
+
+- [كيف تستخدم البرنامج](#how-to-use)
+
+- [النماذج المدعومة](#supported-models)
+
+- [تحذير بشأن تشغيل البرنامج بشكل مستمر](#continous-script-warning)
+
+# كيف يعمل
+
+يعمل البرنامج عبر تشغيل دورة لا نهائية loop تقوم بالخطوات التالية:
+1. جلب المهمة الأولى من قائمة المهام.
+2. إرسال المهمة إلى "وكيل تنفيذ" والذي يستخدم API لـ OpenAI لإكمال المهمة بناءً على السياق.
+3. تحسين النتيجة وتخزينها في [Chroma](docs.trychroma.com).
+4. إنشاء مهام جديدة وإعادة ترتيب قائمة المهام بناءً على الهدف ونتيجة المهمة السابقة.
+
+
+> يتم استخدام "وكيل Agent" للتعبير عن الوظيفة Function التي يقوم بها البرنامج بناءً على الهدف.
+
+
+
+وظيفة تنفيذ مهمة `execution_agent()` ، تأخذ (هدف محدد، مهمة محددة): هنا يتم إرسال Prompt تحتوي على وصف وظيفة التنفيذ كتعليمات، والهدف الذي تم تحديده والمهمة التي تم إنشائها كسياق لطلب توليدي إلى OpenAI API حيث يقوم بتوليد نتيجة تنفيذ المهمة نصياً.
+
+
+
+وظيفة إنشاء مهمة `task_creation_agent()` ، تأخذ (هدف محدد، نتيجة المهمة السابقة، وصف المهمة، قائمة المهام الحالية): هنا يتم إرسال Prompt تحتوي على وصف وظيفة إنشاء المهام كتعليمات، وباقي المتغيرات كسياق لطلب توليدي إلى OpenAI API حيث يقوم بتوليد قائمة مهام على شكل نص.
+
+
+
+وظيفة ترتيب المهام حسب الأولية `prioritization_agent()` ، تأخذ (معرّف المهمة الحالية): هنا يتم إرسال Prompt تحتوي على وصف وظيفة ترتيب المهام كتعليمات، وقائمة المهام و المهمة الحالية كسياق لطلب توليدي إلى Open AI API حيث يقوم بتوليد قائمة مهام جديدة -معاد ترتيبها- على شكل نص.
+
+
+
+أخيراً، يستخدم التطبيق قاعدة بيانات Chroma لتخزين قوائم المهام، ونتائج المهام المكتملة وبيانات إضافية Metadata لاستخدامها لاحقاً كسياق. التخزين يتم بمجموعة (جدول) يتم إنشاؤه بناءً على الاسم الذي تم تحديده عبر المتغير `TABLE_NAME`
+
+
+# طريقة الإستخدام
+
+لاستخدام البرنامج، ستحتاج إلى إتباع هذه الخطوات:
+
+1. استنسخ المستودع عن طريق الأمر `git clone https://github.com/yoheinakajima/babyagi.git` وانتقل إلى المجلد الجديد باستخدام الأمر `cd`
+2. قم بتثبيت الحزم المطلوبة: ` pip install -r requirements.txt` (يفضل استخدام بيئة Python افتراضية)
+3. قم بنسخ ملف `.env.example` إلى `.env` حيث يجب تعديل عدة متغيرات:
+- قم بتعيين مفتاح API OpenAI الخاص بك في المتغير ` OPENAI_API_KEY` والنموذج عبر المتغير ` OPENAPI_API_MODEL`
+- قم بتعيين اسم الجدول الذي سيتم تخزين نتائج المهام فيه في المتغير ` TABLE_NAME`
+- (اختياري) قم بتعيين اسم BabyAGI في المتغير ` BABY_NAME`
+- (اختياري) قم بتعيين هدف نظام إدارة المهام في المتغير ` OBJECTIVE`
+- (اختياري) قم بتعيين أول مهمة للنظام في المتغير ` INITIAL_TASK`
+4. قم بتشغيل البرنامج باستخدام الأمر `python babyagi.py`
+كل القيم الاختيارية يمكن ايضاً تمريرها عبر أمر تشغيل البرنامج.
+
+
+# التشغيل عبر Docker
+
+ستحتاج إلى تثبيت Docker و Docker Compose.
+Docker Desktop هو الخيار الأسهل https://www.docker.com/products/docker-desktop
+
+لتشغيل النظام داخل حاوية Docker ، قم بتعيين ملف .env الخاص بك وفقًا لخطوات أعلاه ثم قم بتشغيل الأمر التالي:
+
+```
+docker-compose up
+```
+
+# النماذج المدعومة
+
+هذا البرنامج يدعم جميع النماذج المتوفرة عبر OpenAI API وايضاً نماذج Llama عبر Llama.cpp. النموذج الافتراضي هو **gpt-3.5-turbo**. لتغيير النموذج، قم بتغيير قيمة المتغير `LLM_MODEL` او عبر واجهة الأوامر.
+
+
+## Llama
+
+لاستخدام نموذج Llama، ستحتاج إلى تثبيت الحزمة llama-cpp. ستحتاج أيضاً إلى أوزان النموذج.
+
+- **لا تقم بمشاركة أي روابط IPFS أو تورينت أو أي روابط أخرى لتحميل النماذج في أي مكان في هذا المستودع، بما في ذلك في المشاكل والنقاشات أو طلبات المساهمة PRs. سيتم حذفها على الفور.**
+
+اذا كنت تملك المتطلبات لتشغيل Llama.cpp قم بتغيير قيمة المتغير `LLAMA_MODEL_PATH` لموقع النموذج المراد استخدامه. للسهولة، يمكنك ربط مجلد `models` في مستودع BabyAGI بالمجلد الذي يحتوي على أوزان النموذج. ثم قم بتشغيل البرنامج مع تحديد قيمة المتغير `LLM_MODEL=llama` أو عبر متغير `-l` في واجهة الأوامر.
+
+# تحذير
+
+هذا البرنامج مصمم ليعمل بشكل مستمر كجزء من نظام إدارة المهام. يمكن أن يؤدي تشغيل هذا البرنامج بشكل مستمر إلى استهلاك عالي من واجهة برمجة التطبيقات (API) من OpenAI، لذا يرجى استخدامه بحذر. بالإضافة إلى ذلك، يتطلب البرنامج أن يتم إعداد واجهات برمجة التطبيقات APIs لكلٍ من OpenAI و Chroma بشكل صحيح، لذا يرجى التأكد من الإعدادات قبل تشغيل البرنامج.
+
+
+# المساهمة
+
+
+لا يوجد شك في أن BabyAGI لا يزال في مرحلة الطفولة وبالتالي نحن لا نزال نحدد اتجاهه والخطوات اللازمة للوصول إليه. حاليًا، الهدف التصميمي الرئيسي لـ BabyAGI هو أن يكون _بسيطًا_ بحيث يكون من السهل فهمه والبناء عليه. للحفاظ على هذه البساطة، نطلب بلطف منك الالتزام بالإرشادات التالية عند تقديم الـ PRs:
+
+- ركّز على التعديلات الصغيرة و المتفرقة بدلاً من إعادة التصميم الشاملة.
+- عند إدخال ميزات جديدة، يرجى تقديم وصفًا مفصلاً لحالة الاستخدام المحددة التي تعمل عليها.
+
+ملاحظة من @yoheinakajima (5 أبريل 2023):
+> أنا أعرف أن هناك عدد كبير من الـPRs، وأقدر صبركم -كما أنني جديد في البرمجيات مفتوحة المصدر وGitHub، ولم أقم بتخطيط وقت توفري بشكل مناسب هذا الأسبوع. إعادة توجيه: كنت مشتتا بين البساطة والتوسع- أنا أميل حاليًا إلى الحفاظ على BabyAGI الأساسي ببساطة، و استخدامه كمنصة لدعم وتعزيز مختلف الطرق للتوسع في هذا الصدد (على سبيل المثال BabyAGIxLangchain كاتجاه واحد) اعتقد أن هناك عدة طرق مثيرة التي تستحق الاستكشاف، وأرى قيمة في وجود مكان مركزي للمقارنة والنقاش. المزيد من التحديثات قادمة قريبًا.
+
+
+أنا جديد في GitHub والبرمجيات مفتوحة المصدر، لذلك يرجى التحلي بالصبر أثناء تعلمي لإدارة هذا المشروع بشكل صحيح. أنا أدير شركة استثمار مالي VC بالنهار، لذلك سأقوم بمراجعة طلبات المساهمة والمشاكل في الليل بعد أن أقوم بوضع أولادي في السرير - مما قد لا يكون كل ليلة. مفتوح لفكرة دعم إضافي، وسأكون تحديث هذا القسم قريبًا (التوقعات، الأفكار، الخ). أقوم بالتحدث إلى الكثير من الناس والتعلم - انتظروا التحديثات!
+
+# مشاريع مستوحاة من BabyAGI
+
+منذ صدوره، أثار BabyAGI اهتماما كبيرًا. يمكنك مشاهدة جميع المشاريع المستوحاة من BabyAGI [هنا](docs/inspired-projects.md).
+
+# قصة BabyAGI
+
+BabyAGI هو برنامج مبسط من الفكرة الرئيسية التي تم تقديمها في [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 مارس 2023). هذه النسخة البسيطة تتكون من 140 سطرًا: 13 تعليقات، 22 خطًا فارغًا = 105 سطرًا من التعليمات البرمجية.
+
+ الاسم تم اقتراحه من قبل الناس ضمن الردود على التغريدة الأصلية، والمؤلف لا يدّعي ان هذا ذكاء عام اصطناعي.
+
+
+صُنع بحب من قبل [@yoheinakajima](https://twitter.com/yoheinakajima)، أعمل كمستثمر VC و سأحب سماع ما تقوم ببناؤه!
+
+
\ No newline at end of file
diff --git a/docs/README-bn.md b/docs/README-bn.md
new file mode 100644
index 00000000..0f780840
--- /dev/null
+++ b/docs/README-bn.md
@@ -0,0 +1,110 @@
+
+ babyagi
+
+
+# উদ্দেশ্য
+
+এই পাইথন স্ক্রিপ্টটি একটি এআই-শক্তিমত্তা সম্পন্ন টাস্ক ম্যানেজমেন্ট সিস্টেমের উদাহরণ। সিস্টেমটি OpenAI এবং vector ডেটাবেইজ ব্যবহার করে, যেমন ক্রোমা বা উইভিয়েট ব্যবহার করে কাজগুলি তৈরি করতে, অগ্রাধিকার দিতে এবং কার্যকর করতে। এই সিস্টেমের মূল ধারণা হল, এটি পূর্ববর্তী কাজের ফলাফল এবং একটি পূর্বনির্ধারিত উদ্দেশ্যের উপর ভিত্তি করে কাজ তৈরি করে থাকে। স্ক্রিপ্টটি তখন উদ্দেশ্যের উপর ভিত্তি করে নতুন কাজ তৈরি করতে ওপেনএআই-এর ন্যাচারাল ল্যাংগুয়েজ প্রসেসিং (NLP) ক্ষমতা ব্যবহার করে, এবং প্রেক্ষাপটের জন্য টাস্ক ফলাফল সংরক্ষণ এবং পুনরুদ্ধারে ক্রোমা/উইভিয়েট ব্যবহার করে থাকে। এটি [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) এর একটি পেয়ার্ড ডাউন ভার্সন।
+
+
+README নিম্নলিখিত বিষয়গুলো কাভার করবে:
+
+- [স্ক্রিপট যেভাবে কাজ করে](#how-it-works)
+
+- [যেভাবে ব্যবহার করা যাবে](#how-to-use)
+
+- [সাপোর্টেড মডেলসমূহ](#supported-models)
+
+- [ক্রমাগত স্ক্রিপ্ট চালাতে সতর্কতা](#continous-script-warning)
+
+# স্ক্রিপ্ট যেভাবে কাজ করে
+
+স্ক্রিপ্টটি একটি অসীম লুপ চালানোর মাধ্যমে নিম্নলিখিত পদক্ষেপগুলি সম্পন্ন করে:
+
+1. টাস্ক লিস্ট থেকে প্রথম টাস্ক টানে।
+2. এক্সিকিউশন এজেন্টের কাছে টাস্কটি পাঠায়, যেটি প্রেক্ষাপটের উপর ভিত্তি করে কাজটি সম্পূর্ণ করতে OpenAI এর API ব্যবহার করে থাকে।
+3. ফলাফলটি সমৃদ্ধ করে এবং এখানে [Chroma](https://docs.trychroma.com)/[Weaviate](https://weaviate.io/) সংরক্ষণ করে।
+4. নতুন টাস্ক তৈরি করে এবং আগের টাস্কের উদ্দেশ্য এবং ফলাফলের উপর ভিত্তি করে টাস্ক লিস্টকে পুনরায় প্রাধান্য দেয়।
+
+
+
+
+`execution_agent()` ফাংশনে OpenAI এর API ব্যবহার করা হয়। এটির দুইটি প্যারামিটার লাগে: উদ্দেশ্য এবং টাস্ক। এরপর এটি OpenAI API এ একটি প্রম্পট পাঠায়, যা টাস্কের ফলাফল প্রদান করে। প্রম্পটে AI সিস্টেমের টাস্ক, উদ্দেশ্য এবং টাস্কের বিবরণ থাকে। এরপর ফলাফলটি একটি স্ট্রিং হিসাবে ফিরে আসে।
+
+`task_creation_agent()` ফাংশন হল যেখানে OpenAI এর API উদ্দেশ্য এবং পূর্ববর্তী টাস্কের ফলাফলের উপর ভিত্তি করে নতুন টাস্ক তৈরি করতে ব্যবহার করা হয়। ফাংশনটি চারটি প্যারামিটার গ্রহন করে: উদ্দেশ্য, পূর্ববর্তী টাস্কের ফলাফল, টাস্কের বিবরণ এবং বর্তমান টাস্ক লিস্ট। তারপরে এটি OpenAI এর API-তে একটি প্রম্পট পাঠায়, যা স্ট্রিং হিসাবে নতুন কাজের একটি তালিকা প্রদান করে। ফাংশনটি এরপর নতুন টাস্কগুলিকে একটি ডিকশনারির লিস্ট হিসাবে ফিরিয়ে দেয়, যেখানে প্রতিটি ডিকশনারিতে টাস্কের নাম থাকে।
+
+`prioritization_agent()` ফাংশন OpenAI এর API টাস্ক লিস্টকে পুনঃঅগ্রাধিকার দেয়ার জন্য ব্যবহার করা হয়। ফাংশনটি একটি প্যারামিটার নেয়, বর্তমান টাস্কের আইডি। এটি OpenAI এর API-তে একটি প্রম্পট পাঠায়, যা পুনঃঅগ্রাধিকার টাস্ক লিস্টকে একটি সংখ্যাযুক্ত লিস্ট হিসাবে প্রদান করে।
+
+অবশেষে, স্ক্রিপ্টটি প্রেক্ষাপটের জন্য টাস্কের ফলাফলগুলি সংরক্ষণ এবং পুনরুদ্ধার করতে Chroma/Weaviate ব্যবহার করে। স্ক্রিপ্টটি TABLE_NAME ভেরিয়েবলে নির্দিষ্ট করা টেবিল নামের উপর ভিত্তি করে একটি Chroma/Weaviate সংগ্রহ তৈরি করে। এরপরে ক্রোমা/উইভিয়েট ব্যবহার করে টাস্কের নাম এবং অতিরিক্ত মেটাডেটা সহ টাস্কের ফলাফল সংরক্ষণ করতে ব্যবহৃত হয়।
+
+# যেভাবে ব্যবহার করা যাবে
+
+স্ক্রিপ্ট ব্যবহার করতে, নিম্নলিখিত পদক্ষেপ অনুসরণ করতে হবে:
+
+1. রিপোজিটরি ক্লোন `git clone https://github.com/yoheinakajima/babyagi.git` এবং `cd` এর মাধ্যমে ডিরেক্টোরিতে প্রবেশ করুন।
+2. প্রয়োজনীয় প্যাকেজ ইনস্টল করতে: `pip install -r requirements.txt`
+3. .env.example ফাইলটি .env তে কপি করুন: `cp .env.example .env` এখানে আপনি নিম্নলিখিত ভেরিয়েবল সেট করবেন।
+4. OPENAI_API_KEY এবং OPENAPI_API_MODEL ভেরিয়েবলে আপনার OpenAI API কী সেট করুন। Weaviate এর সাথে ব্যবহার করার জন্য আপনাকে অতিরিক্ত ভেরিয়েবল সেটআপ করতে হবে [এখানে](docs/weaviate.md)।
+5. টেবিলের নাম সেট করুন যেখানে টাস্ক ফলাফলগুলি TABLE_NAME ভেরিয়েবলে সংরক্ষণ করা হবে৷
+6. (ঐচ্ছিক) BABY_NAME ভেরিয়েবলে BabyAGI উদাহরণের নাম সেট করুন।
+7. (ঐচ্ছিক) Objective ভেরিয়েবলে টাস্ক ম্যানেজমেন্ট সিস্টেমের উদ্দেশ্য সেট করুন।
+8. (ঐচ্ছিক) সিস্টেমের প্রথম কাজটি INITIAL_TASK ভেরিয়েবলে সেট করুন।
+9. স্ক্রিপ্টটি চালান: `python babyagi.py`
+
+উপরের সকল ঐচ্ছিক মানগুলো কমান্ড লাইনেও সেট করা যাবে।
+
+# Docker container এ চালতে হলে
+
+পূর্বশর্ত হিসাবে, আপনার docker এবং docker-compose ইনস্টল থাকতে হবে। docker desktop হল সবচেয়ে সহজ বিকল্প https://www.docker.com/products/docker-desktop/
+
+docker কন্টেইনারে সিস্টেম চালানোর জন্য উপরের ধাপ অনুযায়ী আপনার .env ফাইল সেটআপ করুন এবং তারপরে নিম্নলিখিত কমান্ড রান করুন:
+
+```
+docker-compose up
+```
+
+# সাপোর্টেড মডেলসমূহ
+
+এই স্ক্রিপ্টটি সকল OpenAI মডেলের সাথে কাজ করে, একই সাথে Llama এবং Llama.cpp এর সাহায্যে এর অন্যান্য প্রকরনের সাথওে কাজ করে। ডিফল্ট মডেল হল **gpt-3.5-টার্বো**। ভিন্ন মডেল ব্যবহার করতে, LLM_MODEL এর মাধ্যমে এটি নির্দিষ্ট করুন বা কমান্ড লাইন ব্যবহার করুন৷
+
+## Llama
+
+Llama ইন্টিগ্রেশনের জন্য llama-cpp প্যাকেজ প্রয়োজন। আপনার Llama model weights ও প্রয়োজন হবে৷
+
+- **কোন অবস্থাতেই আইপিএফএস, ম্যাগনেট লিঙ্ক বা মডেল ডাউনলোডের অন্য কোনও লিঙ্ক এই রিপোজিটরির কোথাও শেয়ার করবেন না, যার মধ্যে ইস্যু, ডিসকাশন বা পুল রিকুয়েষ্ট অন্তর্ভুক্ত। সেগুলো অবিলম্বে মুছে ফেলা হবে।**
+
+যখন আপনার কাছে প্রয়োজনীয় সবকিছু থাকবে, তখন ব্যবহার করার জন্য নির্দিষ্ট মডেলের পাথে LLAMA_MODEL_PATH সেট করুন৷ আপনার সুবিধার জন্য, আপনি BabyAGI রেপোতে `models` লিঙ্ক করতে পারেন সেই ফোল্ডারে যেখানে আপনার Llama model weights আছে। তারপর `LLM_MODEL=llama` বা `-l` আর্গুমেন্ট দিয়ে স্ক্রিপ্টটি চালান।
+
+# সতর্কতা
+
+এই স্ক্রিপ্টটি টাস্ক ম্যানেজমেন্ট সিস্টেমের অংশ হিসাবে ক্রমাগত চালানোর জন্য ডিজাইন করা হয়েছে। এই স্ক্রিপ্টটি ক্রমাগত চালানোর ফলে উচ্চ API ব্যবহার হতে পারে, তাই দয়া করে দায়িত্বের সাথে এটি ব্যবহার করুন। উপরন্তু, স্ক্রিপ্টের জন্য OpenAI API সঠিকভাবে সেট আপ করা প্রয়োজন, তাই স্ক্রিপ্ট চালানোর আগে নিশ্চিত করুন যে আপনি API সেট আপ করেছেন।
+
+# Contribution
+
+বলা বাহুল্য, BabyAGI এখনও তার শৈশবকালে রয়েছে এবং এইভাবে আমরা এখনও এর লক্ষ্য এবং সেখানে পৌছানোর পদক্ষেপগুলি নির্ধারণ করছি। বর্তমানে, BabyAGI-এর জন্য একটি মূল ডিজাইন লক্ষ্য হল _simple_ হওয়া যাতে এটি সহজে বোঝা এবং তৈরি করা যায়। এই সরলতা বজায় রাখার জন্য, আমরা অনুরোধ করছি যে আপনি PR জমা দেওয়ার সময় নিম্নলিখিত নির্দেশিকাগুলি মেনে চলুন:
+
+- ব্যাপক রিফ্যাক্টরিংয়ের পরিবর্তে ছোট, মডুলার পরিবর্তনগুলিতে ফোকাস করুন।
+- নতুন বৈশিষ্ট্যগুলি প্রবর্তন করার ক্ষেত্রে, আপনি যে নির্দিষ্ট ব্যবহারের ক্ষেত্রে সম্বোধন করছেন তার একটি বিশদ বিবরণ প্রদান করুন৷
+
+@yoheinakajima'র মন্তব্য (Apr 5th, 2023):
+
+> জানি এখন PR ক্রমবর্ধমান, আমি আপনার ধৈর্যের প্রশংসা করি - যেহেতু আমি GitHub এবং OpenSource-এ নতুন, এবং এই সপ্তাহে আমার সময় প্রাপ্যতার পরিকল্পনা করিনি। পুনঃনির্দেশ, আমি এটিকে সরল একইসাথে প্রসারিত রাখার বিষয়ে হিমশিম খাচ্ছি - বর্তমানে একটি মূল বেবি এজিআইকে সরল রাখার দিকে ঝুঁকছি, এবং এটিকে প্রসারিত করার জন্য বিভিন্ন পদ্ধতির সমর্থন ও প্রচার করার জন্য এটিকে একটি প্ল্যাটফর্ম হিসাবে ব্যবহার করছি (যেমন: BabyAGIxLangchain একটি উদাহরণ)। আমি বিশ্বাস করি যে বিভিন্ন মতামতযুক্ত পন্থা রয়েছে যা গবেষণার যোগ্য, এবং আমি তুলনা এবং আলোচনা করার জন্য একটি কেন্দ্রীয় স্থানের মূল্য বুঝি। আরো আপডেট শীঘ্রই আসছে।
+
+আমি গিটহাব এবং ওপেন সোর্সে নতুন, তাই অনুগ্রহ করে ধৈর্য ধরুন কারণ আমি এই প্রকল্পটি সঠিকভাবে পরিচালনা করা শিখছি। আমি দিনে একটি ভিসি ফার্ম চালাই, তাই সাধারণত আমার বাচ্চারা ঘুমানোর পরে রাতে PR এবং সমস্যাগুলি পরীক্ষা করব - যা প্রতি রাতে নাও হতে পারে। যেকোনো ধরনের সহযোগিতার সমর্থন করছি, শীঘ্রই এই বিভাগটি আপডেট করা হবে (প্রত্যাশা, দৃষ্টিভঙ্গি, ইত্যাদি)। অনেক মানুষের সাথে কথা বলছি এবং শিখছি - আপডেটের জন্য অপেক্ষা করুন!
+
+# BabyAGI কার্যকলাপ রিপোর্ট
+
+BabyAGI কমিউনিটিকে প্রকল্পের অগ্রগতি সম্পর্কে অবগত থাকতে সাহায্য করার জন্য, Blueprint AI BabyAGI-এর জন্য একটি Github কার্যকলাপ সংক্ষিপ্তসার তৈরি করেছে৷ এই সংক্ষিপ্ত প্রতিবেদনটি গত 7 দিনে BabyAGI সংগ্রহস্থলে সমস্ত অবদানের সংক্ষিপ্তসার প্রদর্শন করে (প্রতিনিয়ত আপডেট করা হচ্ছে), এটি আপনার জন্য বেবি এজিআইএর সাম্প্রতিক বিকাশের উপর নজর রাখা সহজ করে তোলে। BabyAGI এর 7-দিনের কার্যকলাপ রিপোর্ট দেখতে, ক্লিক করুনঃ [https://app.blueprint.ai/github/yoheinakajima/babyagi](https://app.blueprint.ai/github/yoheinakajima/babyagi)
+
+[](https://app.blueprint.ai/github/yoheinakajima/babyagi)
+
+
+# Inspired projects
+
+BabyAGI প্রকাশের পর থেকে অল্প সময়ের মধ্যে অনেক প্রকল্পকে অনুপ্রাণিত করেছে। আপনি সবগুলো দেখতে পারেন [এখানে](docs/inspired-projects.md).
+
+# Backstory
+
+BabyAGI [Task-Driven Autonomous Agent] এর একটি সরলীকৃত ভার্সন (https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) টুইটারে শেয়ার করা হয়েছে। এই সংস্করণটি 140 লাইনের: 13টি মন্তব্য, 22টি শূন্যস্থান এবং 105 লাইন কোড। আসল স্বায়ত্তশাসিত এজেন্টের প্রতিক্রিয়ায় রেপোর নামটি এসেছে - লেখক বোঝাতে চাননা যে এটি AGI।
+
+যত্ন ও ভালবাসা দিয়ে তৈরি করেছেন [@yoheinakajima](https://twitter.com/yoheinakajima), অনাকাঙ্ক্ষিতভাবে যিনি একজন ভিসি (আপনার সৃজনশীলতার বহিঃপ্রকাশ দেখতে আগ্রহী)
diff --git a/docs/README-cn.md b/docs/README-cn.md
new file mode 100644
index 00000000..dd2ea434
--- /dev/null
+++ b/docs/README-cn.md
@@ -0,0 +1,94 @@
+
+
+# Ziel
+
+Dieses Python-Skript ist ein Beispiel für ein KI-gestütztes Aufgabenverwaltungssystem. Das System verwendet OpenAI und Chroma, um Aufgaben zu erstellen, zu priorisieren und auszuführen. Die Hauptidee hinter diesem System ist, dass es Aufgaben basierend auf dem Ergebnis vorheriger Aufgaben und einem vordefinierten Ziel erstellt. Das Skript verwendet dann die Funktionen zur Verarbeitung natürlicher Sprache (NLP) von OpenAI, um neue Aufgaben basierend auf dem Ziel zu erstellen, und Chroma, um Aufgabenergebnisse für den Kontext zu speichern und abzurufen. Dies ist eine abgespeckte Version des ursprünglichen [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28. März 2023).
+
+Diese README-Datei behandelt Folgendes:
+
+- [Wie das Skript funktioniert](#how-it-works)
+
+- [So verwendet man das Skript](#how-to-use)
+
+- [Unterstützte Modelle](#supported-models)
+
+- [Warnung vor der kontinuierlichen Ausführung des Skripts](#continous-script-warning)
+
+# Wie es funktioniert
+
+Das Skript funktioniert, indem es eine Endlosschleife ausführt, die die folgenden Schritte abarbeitet:
+
+1. Zieht die erste Aufgabe aus der Aufgabenliste.
+2. Sendet die Aufgabe an den Ausführungsagenten, der die API von OpenAI verwendet, um die Aufgabe basierend auf dem Kontext abzuschließen.
+3. Reichert das Ergebnis an und speichert es in [Chroma](https://github.com/yoheinakajima/babyagi/blob/main/docs.trychroma.com).
+4. Erstellt neue Aufgaben und priorisiert die Aufgabenliste basierend auf dem Ziel und dem Ergebnis der vorherigen Aufgabe neu.
+
+
+Die Funktion `execute_agent()` ist die Stelle, an dem die OpenAI-API verwendet wird. Sie benötigt zwei Parameter: das Ziel und die Aufgabe. Anschließend sendet sie eine Eingabeaufforderung an die API von OpenAI, die das Ergebnis der Aufgabe zurückgibt. Die Aufforderung besteht aus einer Beschreibung der Aufgabe des KI-Systems, des Ziels und der Aufgabe selbst. Das Ergebnis wird dann als String zurückgegeben.
+
+
+In der Funktion `task_creation_agent()` wird die API von OpenAI verwendet, um neue Aufgaben basierend auf dem Ziel und dem Ergebnis der vorherigen Aufgabe zu erstellen. Die Funktion nimmt vier Parameter entgegen: das Ziel, das Ergebnis der vorherigen Aufgabe, die Aufgabenbeschreibung und die aktuelle Aufgabenliste. Anschließend sendet es eine Eingabeaufforderung an die API von OpenAI, die eine Liste neuer Aufgaben als Zeichenfolgen zurückgibt. Die Funktion gibt dann die neuen Aufgaben als Liste von Wörterbüchern zurück, wobei jedes Wörterbuch den Namen der Aufgabe enthält.
+
+
+In der Funktion `prioritization_agent()` wird die API von OpenAI verwendet, um die Aufgabenliste neu zu priorisieren. Die Funktion übernimmt einen Parameter, die ID der aktuellen Aufgabe. Sie sendet eine Eingabeaufforderung an die API von OpenAI, die die neu priorisierte Aufgabenliste als nummerierte Liste zurückgibt.
+
+
+Schließlich verwendet das Skript Chroma, um Aufgabenergebnisse für den Kontext zu speichern und abzurufen. Das Skript erstellt eine Chroma-Sammlung basierend auf dem Tabellennamen, der in der Variablen TABLE_NAME angegeben ist. Chroma wird dann verwendet, um die Ergebnisse der Aufgabe zusammen mit dem Aufgabennamen und allen zusätzlichen Metadaten in der Sammlung zu speichern.
+
+# Wie man es benutzt
+
+Um das Skript zu verwenden, müssen die folgenden Schritte ausgeführt werden:
+
+1. Klone das Repository über den Befehl `git glone https://github.com/yoheinakajima/babyagi.git` und wechsle mit `cd` in das geklonte Repository.
+2. Installiere die erforderlichen Pakete: `pip install -r requirements.txt`
+3. Kopiere die .env.example-Datei nach .env: `cp .env.example .env`. Hier werden die folgenden Variablen gesetzt.
+4. Lege deinen OpenAI-API-Schlüssel in den Variablen OPENAI_API_KEY und OPENAPI_API_MODEL fest.
+5. Lege den Namen der Tabelle fest, in der die Aufgabenergebnisse in der Variablen TABLE_NAME gespeichert werden.
+6. (Optional) Lege den Namen der BabyAGI-Instanz in der Variablen BABY_NAME fest.
+7. (Optional) Lege das Ziel des Task-Management-Systems in der Variablen OBJECTIVE fest.
+8. (Optional) Lege die erste Aufgabe des Systems in der Variablen INITIAL_TASK fest.
+9. Führe das Skript aus: `python babyagi.py`
+
+Alle obigen optionalen Werte können auch in der Befehlszeile angegeben werden.
+
+# In einem Docker-Container ausführen
+
+Als Voraussetzung müssen Docker und Docker-Compose installiert sein. Docker-Desktop ist die einfachste Option: [https://www.docker.com/products/docker-desktop/](https://www.docker.com/products/docker-desktop/).
+
+Um das System in einem Docker-Container auszuführen, richte deine .env-Datei wie oben beschrieben ein und führe dann folgenden Befehl aus:
+
+```
+docker-compose up
+```
+
+# Unterstützte Modelle
+
+Dieses Skript funktioniert mit allen OpenAI-Modellen sowie mit Llama und seinen Variationen über Llama.cpp. Das Standardmodell ist **gpt-3.5-turbo**. Um ein anderes Modell zu verwenden, geben Sie es über LLM_MODEL an oder verwenden Sie die Befehlszeile.
+
+## Llama
+
+Die Llama-Integration erfordert das Paket [Llama.cpp](https://github.com/ggerganov/llama.cpp). Sie benötigen auch die Gewichte des Llama-Modells.
+
+- **Teilen Sie unter keinen Umständen IPFS, magnet-Links oder andere Links zu Modell-Downloads irgendwo in diesem Repository, auch nicht in Issues, Diskussionen oder Pull-Requests. Sie werden umgehend gelöscht.**
+
+Sobald verfügbar, setze die LLAMA_MODEL_PATH auf den Pfad des spezifischen zu verwendenden Modells. Der Einfachheit halber können Sie `models` im BabyAGI-Repo mit dem Ordner verknüpfen, in dem Sie die Llama-Modellgewichte haben. Führen Sie dann das Skript mit dem Argument `LLM_MODEL=llama` oder `-l` aus.
+
+# Warnung
+
+Dieses Skript wurde entwickelt, um als Teil eines Aufgabenverwaltungssystems kontinuierlich ausgeführt zu werden. Die kontinuierliche Ausführung dieses Skripts kann zu einer hohen API-Nutzung führen, gehe also bitte verantwortungsvoll damit um. Darüber hinaus erfordert das Skript die korrekte Einrichtung der OpenAI-API. Stelle also sicher, dass du die API eingerichtet hast, bevor du das Skript ausführst.
+
+# Beiträge
+
+Unnötig zu sagen, dass BabyAGI noch in den Kinderschuhen steckt und wir daher immer noch die Richtung und die Schritte dorthin bestimmen. Derzeit ist es ein wichtiges Designziel für BabyAGI, so einfach zu sein, dass es leicht zu verstehen und darauf aufzubauen ist. Um diese Einfachheit zu wahren, bitten wir, sich beim Einreichen von PRs an die folgenden Richtlinien zu halten:
+
+- Konzentriere dich auf kleine, modulare Modifikationen statt auf umfangreiches Refactoring.
+- Gebe bei der Einführung neuer Funktionen eine detaillierte Beschreibung des spezifischen Anwendungsfalls an, der angesprochen wird.
+
+Ein Hinweis von @yoheinakajima (Apr 5th, 2023):
+
+> Ich weiß, dass es eine wachsende Zahl von PRs gibt, danke für Ihre Geduld – da ich neu bei GitHub/OpenSource bin und meine zeitliche Verfügbarkeit diese Woche nicht entsprechend geplant habe. Re:direction, ich war hin- und hergerissen, es einfach zu halten oder zu erweitern – derzeit neige ich dazu, ein Kern-Baby-AGI einfach zu halten und dies als Plattform zu verwenden, um verschiedene Ansätze zur Erweiterung zu unterstützen und zu fördern (z. B. BabyAGIxLangchain als eine Richtung). Ich glaube, dass es verschiedene eigensinnige Ansätze gibt, die es wert sind, erkundet zu werden, und ich sehe Wert darin, einen zentralen Ort zum Vergleichen und Diskutieren zu haben. Weitere Updates folgen in Kürze.
+
+Ich bin neu bei GitHub und Open Source, also haben Sie bitte etwas Geduld, während ich lerne, dieses Projekt richtig zu verwalten. Ich leite tagsüber eine VC-Firma, also überprüfe ich im Allgemeinen nachts PRs und Probleme, nachdem ich meine Kinder ins Bett gebracht habe – was möglicherweise nicht jede Nacht der Fall ist. Offen für die Idee, Unterstützung einzubringen, wird dieser Abschnitt bald aktualisiert (Erwartungen, Visionen usw.). Mit vielen Leuten reden und lernen – bleiben Sie dran für Updates!
+
+# Inspirierte Projekte
+
+In der kurzen Zeit seit der Veröffentlichung hat BabyAGI viele Projekte inspiriert. Sie können [hier](https://github.com/yoheinakajima/babyagi/blob/main/docs/inspired-projects.md) angesehen werden.
+
+# Hintergrundgeschichte
+
+BabyAGI ist eine abgespeckte Version des ursprünglichen [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20)(28. März 2023), der auf Twitter geteilt wurde. Diese Version ist auf 140 Zeilen reduziert: 13 Kommentare, 22 Leerzeichen und 105 Code. Der Name des Repos tauchte in der Reaktion auf den ursprünglichen autonomen Agenten auf – der Autor will damit nicht implizieren, dass es sich um AGI handelt.
+
+Mit Liebe gemacht von [@yoheinakajima](https://twitter.com/yoheinakajima), der zufällig ein VC ist (würde gerne sehen, was du baust!)
diff --git a/docs/README-es.md b/docs/README-es.md
new file mode 100644
index 00000000..8a2115b0
--- /dev/null
+++ b/docs/README-es.md
@@ -0,0 +1,87 @@
+
+babyagi
+
+
+
+# Objetivo
+
+Este script de Python es un ejemplo de un sistema de gestión de tareas impulsado por inteligencia artificial. El sistema utiliza las API de OpenAI y Pinecone para crear, priorizar y ejecutar tareas. La idea principal detrás de este sistema es que crea tareas basadas en el resultado de tareas anteriores y un objetivo predefinido. Luego, el script utiliza las capacidades de procesamiento del lenguaje natural (NLP) de OpenAI para crear nuevas tareas basadas en el objetivo, y Pinecone para almacenar y recuperar los resultados de las tareas para el contexto. Esta es una versión simplificada del original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 de marzo de 2023).
+
+Este README cubrirá lo siguiente:
+
+- [Cómo funciona el script](#como-funciona)
+
+- [Cómo utilizar el script](#como-utilizar)
+
+- [Modelos compatibles](#modelos-compatibles)
+
+- [Advertencia sobre la ejecución continua del script](#advertencia-script-continuo)
+
+# Cómo funciona
+
+El script funciona ejecutando un bucle infinito que realiza los siguientes pasos:
+
+1. Extrae la primera tarea de la lista de tareas.
+2. Envía la tarea al agente de ejecución, que utiliza la API de OpenAI para completar la tarea según el contexto.
+3. Enriquece el resultado y lo almacena en Pinecone.
+4. Crea nuevas tareas y prioriza la lista de tareas en función del objetivo y el resultado de la tarea anterior.
+
+
+La función execution_agent() es donde se utiliza la API de OpenAI. Esta toma dos parámetros: el objetivo y la tarea. Luego envía una solicitud a la API de OpenAI, que devuelve el resultado de la tarea. La solicitud consta de una descripción de la tarea del sistema de IA, el objetivo y la tarea en sí. Luego se devuelve el resultado como una cadena.
+
+La función task_creation_agent() es donde se utiliza la API de OpenAI para crear nuevas tareas basadas en el objetivo y el resultado de la tarea anterior. La función toma cuatro parámetros: el objetivo, el resultado de la tarea anterior, la descripción de la tarea y la lista de tareas actual. Luego envía una solicitud a la API de OpenAI, que devuelve una lista de nuevas tareas como strings. Luego, la función devuelve las nuevas tareas como una lista de diccionarios, donde cada diccionario contiene el nombre de la tarea.
+
+La función prioritization_agent() es donde se utiliza la API de OpenAI para priorizar la lista de tareas. La función toma un parámetro, el ID de la tarea actual. Luego envía una solicitud a la API de OpenAI, que devuelve la lista de tareas repriorizadas como una lista numerada.
+
+Finalmente, el script utiliza Pinecone para almacenar y recuperar los resultados de las tareas para el contexto. El script crea un índice Pinecone basado en el nombre de la tabla especificado en la variable YOUR_TABLE_NAME. Luego, Pinecone se utiliza para almacenar los resultados de la tarea en el índice, junto con el nombre de la tarea y cualquier metadato adicional.
+
+# Cómo utilizar el script
+
+Para utilizar el script, deberá seguir estos pasos:
+
+1. Clonar el repositorio a través de `git clone https://github.com/yoheinakajima/babyagi.git` y `cd` en el repositorio clonado.
+2. Instalar los paquetes requeridos: `pip install -r requirements.txt`
+3. Copiar el archivo .env.example a .env: `cp .env.example .env`. Aquí es donde establecerá las siguientes variables.
+4. Establezca sus claves de API de OpenAI y Pinecone en las variables OPENAI_API_KEY, OPENAPI_API_MODEL y PINECONE_API_KEY.
+5. Establezca el entorno de Pinecone en la variable PINECONE_ENVIRONMENT.
+6. Establezca el nombre de la tabla donde se almacenarán los resultados de la tareas en la variable TABLE_NAME.
+7. (Opcional) Establezca el objetivo del sistema de gestión de tareas en la variable OBJECTIVE.
+8. (Opcional) Establezca la primera tarea del sistema en la variable INITIAL_TASK.
+9. Ejecute el script.
+
+Todos los valores opcionales anteriores también se pueden especificar en la línea de comando.
+
+# Modelos compatibles
+
+Este script funciona con todos los modelos de OpenAI, así como con Llama a través de Llama.cpp. El modelo predeterminado es **gpt-3.5-turbo**. Para utilizar un modelo diferente, especifíquelo a través de OPENAI_API_MODEL o utilice la línea de comando.
+
+## Llama
+
+Descargue la última versión de [Llama.cpp](https://github.com/ggerganov/llama.cpp) y siga las instrucciones para compilarla. También necesitará los pesos del modelo Llama.
+
+- **Bajo ninguna circunstancia comparta enlaces IPFS, enlaces magnet o cualquier otro enlace para descargar modelos en cualquier lugar de este repositorio, incluyendo propuestas (issues), debates (discussions) o solicitudes de extracción (pull requests). Serán eliminados de inmediato.**
+
+Después de eso, enlace `llama/main` a llama.cpp/main y `models` a la carpeta donde tenga los pesos del modelo Llama. Luego ejecute el script con `OPENAI_API_MODEL=llama` o el argumento `-l`.
+
+# Advertencia
+
+Este script está diseñado para ser ejecutado continuamente como parte de un sistema de gestión de tareas. La ejecución continua de este script puede resultar en un alto uso de la API, así que úselo responsablemente. Además, el script requiere que las APIs de OpenAI y Pinecone estén configuradas correctamente, así que asegúrese de haber configurado las APIs antes de ejecutar el script.
+
+# Contribución
+
+Como es obvio, BabyAGI todavía está en su infancia y, por lo tanto, todavía estamos determinando su dirección y los pasos a seguir. Actualmente, un objetivo de diseño clave para BabyAGI es ser _simple_ para que sea fácil de entender y construir sobre ella. Para mantener esta simplicidad, solicitamos amablemente que se adhiera a las siguientes pautas al enviar solicitudes de extracción (PR):
+
+- Enfóquese en modificaciones pequeñas y modulares en lugar de refactorizaciones extensas.
+- Al introducir nuevas funciones, proporcione una descripción detallada del caso de uso específico que está abordando.
+
+Una nota de @yoheinakajima (5 de abril de 2023):
+
+> I know there are a growing number of PRs, appreciate your patience - as I am both new to GitHub/OpenSource, and did not plan my time availability accordingly this week. Re:direction, I've been torn on keeping it simple vs expanding - currently leaning towards keeping a core Baby AGI simple, and using this as a platform to support and promote different approaches to expanding this (eg. BabyAGIxLangchain as one direction). I believe there are various opinionated approaches that are worth exploring, and I see value in having a central place to compare and discuss. More updates coming shortly.
+
+Soy nuevo en GitHub y en código abierto, así que por favor tenga paciencia mientras aprendo a administrar este proyecto adecuadamente. Dirijo una empresa de capital de riesgo durante el día, por lo que generalmente revisaré las solicitudes de extracción y los problemas por la noche después de acostar a mis hijos, lo que puede no ser todas las noches. Estoy abierto a la idea de traer soporte y actualizaré esta sección pronto (expectativas, visiones, etc). Estoy hablando con muchas personas y aprendiendo, ¡esperen actualizaciones pronto!
+
+# Antecedentes
+
+BabyAGI es una versión simplificada de [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 de marzo de 2023) compartido en Twitter. Esta versión se ha reducido a 140 líneas: 13 comentarios, 22 líneas en blanco y 105 líneas de código. El nombre del repositorio surgió como reacción al agente autónomo original, y el autor no pretende implicar que esto sea AGI.
+
+Hecho con amor por [@yoheinakajima](https://twitter.com/yoheinakajima), que casualmente es un VC (¡me encantaría ver lo que estás construyendo!).
diff --git a/docs/README-fa.md b/docs/README-fa.md
new file mode 100644
index 00000000..d92dfe55
--- /dev/null
+++ b/docs/README-fa.md
@@ -0,0 +1,143 @@
+
+babyagi
+
+
+# هدف
+
+این اسکریپت پایتون یک نمونه سیستم مدیریت وظایف توانمند هوش مصنوعی است. این سیستم با استفاده از API های OpenAI و Pinecone، وظایف را ایجاد، اولویت بندی و اجرا می کند. ایده اصلی پشت این سیستم این است که وظایف بر اساس نتیجه وظایف قبلی و هدف پیش تعریف شده ایجاد می شوند. سپس این اسکریپت از قابلیت های پردازش زبان طبیعی (NLP) OpenAI برای ایجاد وظایف جدید براساس هدف استفاده می کند، و از Pinecone برای ذخیره و بازیابی نتایج وظایف برای کانتکست استفاده می کند. این یک نسخه کوچکتر از [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 مارس 2023) است.
+
+
+
+# موضوعات
+
+- [نحوه کارایی](#how-it-works)
+
+- [نحوه استفاده](#how-to-use)
+
+- [مدل های پشتیبانی شده](#supported-models)
+
+- [ملاحظات در خصوص ران کردن اسکریپت](#continous-script-warning)
+
+# نحوه کارایی
+
+این کسریپت اینگونه کار میکند که در یک لوپ به صورت متدادم:
+
+1. وظیفه اول رو از لیست وظایف میگیرد
+2. وظیفه را به عامل اجرایی ارسال میکند که با استفاده از API OpenAI بر اساس متن، وظیفه را انجام میدهد.
+3. نتیجه را تقویت کرده و در Pinecone ذخیره میکند..
+4. وظایف جدید را ایجاد کرده و با توجه به هدف و نتیجه وظیفه قبلی، اولویت و لیست وظایف را مجدداً تنظیم میکند.
+
+
+
+
+تابع execution_agent() جایی است که از API OpenAI استفاده میشود. این تابع دو پارامتر دریافت میکند: هدف و وظیفه. سپس یک پرامپت (prompt) به API OpenAI ارسال میکند که نتیجه وظیفه را برمیگرداند. پرامپت شامل توصیفی از وظیفه سیستم هوش مصنوعی، هدف و وظیفه خود است. نتیجه به عنوان یک رشته (string) برگشت داده میشود.
+
+تابع task_creation_agent() جایی است که از API OpenAI برای ایجاد وظایف جدید براساس هدف و نتیجه وظیفه قبلی استفاده میشود. این تابع چهار پارامتر دریافت میکند: هدف، نتیجه وظیفه قبلی، شرح وظیفه و لیست کنونی وظایف. سپس یک پرامپت (prompt) به API OpenAI ارسال میشود که لیستی از وظایف جدید را به صورت رشتهها برمیگرداند. سپس تابع وظایف جدید را به عنوان یک لیست دیکشنری برمیگرداند، که هر دیکشنری شامل نام وظیفه است.
+
+تابع prioritization_agent() جایی است که از API OpenAI برای تنظیم مجدد اولویت لیست وظایف استفاده میشود. این تابع یک پارامتر، یعنی شناسه وظیفه جاری را دریافت میکند. سپس یک پرامپت (prompt) به API OpenAI ارسال میشود که لیست وظایف تنظیم شده مجدداً به صورت لیست شمارهدار برمیگرداند.
+
+در نهایت، این اسکریپت از Pinecone برای ذخیره و بازیابی نتایج وظایف برای کانتکست استفاده میکند. اسکریپت یک فهرست Pinecone براساس نام جدول مشخص شده در متغیر YOUR_TABLE_NAME ایجاد میکند. Pinecone سپس برای ذخیره نتایج وظایف در این فهرست، به همراه نام وظیفه و هر فضای متادیتا اضافی استفاده میشود.
+
+
+# نحوه استفاده
+
+برای استفاده از این اسکریپت، باید مراحل زیر را دنبال کنید:
+
+1. کلون کردن مخزن
+```
+git clone https://github.com/yoheinakajima/babyagi.git
+cd babyagi
+```
+2. نصب پکیج های مورد نیاز
+```
+pip install -r requirements.txt
+```
+
+3. کپی کردن فایل .env.example به .env
+```
+cp .env.example .env
+```
+
+4. تنظیم کلیدهای API OpenAI و Pinecone
+متغیرهای زیر را در فایل .env ویرایش کنید:
+```
+OPENAI_API_KEY=
+OPENAPI_API_MODEL=
+PINECONE_API_KEY=
+```
+
+5. تنظیم محیط Pinecone
+متغیر زیر را در فایل .env ویرایش کنید:
+```
+PINECONE_ENVIRONMENT=
+```
+
+6. تنظیم نام جدول برای نتایج وظایف
+متغیر زیر را در فایل .env ویرایش کنید:
+```
+TABLE_NAME=
+```
+
+7. (اختیاری): تنظیم نام BabyAGI
+متغیر زیر را در فایل .env ویرایش کنید:
+```
+BABY_NAME=
+```
+
+8. (اختیاری): تنظیم هدف سیستم مدیریت وظایف
+متغیر زیر را در فایل .env ویرایش کنید:
+```
+OBJECTIVE=
+```
+
+9. (اختیاری): تنظیم اولین وظیفه سیستم
+متغیر زیر را در فایل .env ویرایش کنید:
+```
+INITIAL_TASK=
+```
+
+10. اجرای اسکریپت
+```
+python babyagi.py
+```
+
+
+# اجرای اسکریپت داخل یک کانتینر Docker
+
+در این روش، نیاز به نصب docker و docker-compose دارید. سادهترین راه برای نصب Docker Desktop است https://www.docker.com/products/docker-desktop/
+
+برای اجرای سیستم داخل یک کانتینر Docker، ابتدا فایل .env را مطابق با مراحل بالا تنظیم کنید، سپس دستور زیر را اجرا کنید:
+
+```
+docker-compose up
+```
+
+
+# مدلهای پشتیبانی شده
+
+این اسکریپت با تمام مدلهای OpenAI و همچنین Llama از طریق Llama.cpp کار میکند. مدل پیشفرض **gpt-3.5-turbo** است. برای استفاده از مدل دیگر، آن را از طریق OPENAI_API_MODEL مشخص کنید یا از خط فرمان استفاده کنید.
+
+## Llama
+
+آخرین نسخه [Llama.cpp](https://github.com/ggerganov/llama.cpp) را دانلود کنید و دستورالعملهای نصب آن را دنبال کنید. همچنین نیاز به وزن مدل Llama دارید.
+
+- **هیچگاه لینکهای IPFS، magnet و هرگونه لینک دانلود مدل را در هیچ قسمتی از این مخزن، از جمله issues، discussions و pull requests به اشتراک نگذارید. لینکها به صورت فوری حذف میشوند.**
+
+پس از آن، پوشه `llama/main` را به `llama.cpp/main` و `models` را به پوشهای که وزن مدل Llama در آن قرار دارد متصل کنید. سپس اسکریپت را با استفاده از `OPENAI_API_MODEL=llama` یا `-l` اجرا کنید.
+
+# هشدار
+
+این اسکریپت برای اجرای پیوسته به عنوان یک سیستم مدیریت وظایف طراحی شده است. اجرای پیوسته این اسکریپت میتواند منجر به استفاده بالای API شود، لطفاً با مسئولیت کاربردی از
+
+
+
+# مشارکت
+
+بدیهی است که BabyAGI هنوز در دوران نوزادی خود است و به همین دلیل هنوز داریم جهت آن و گامهای لازم برای رسیدن به آن را تعیین میکنیم. هدف طراحی برای BabyAGI در حال حاضر این است که _ساده_ باشد تا به راحتی قابل فهم و گسترش باشد. برای حفظ این سادگی، لطفاً در هنگام ارسال PRs به دستورالعملهای زیر عمل کنید:
+
+- تمرکز بر تغییرات کوچک و ماژولار به جای بازسازی گسترده.
+- هنگام معرفی ویژگیهای جدید، یک توضیح جزئیاتی از مورد کاربرد خاصی که شما در حال حاضر با آن مواجه هستید، ارائه دهید.
+
+یک نکته از طرف @yoheinakajima (۵ آوریل ۲۰۲۳):
+
+> من میدانم که تعداد PRها در حال افزایش است و از صبر شما قدردانی میکنم - زیرا من همزمان با تازه وارد بودن به GitHub/OpenSource و برنامه ریزی نکردن وقت خود در این هفته مواجه هستم. در مورد جهت، من در دو دسته نگه داشتن آن ساده یا گسترده تر بودم - در حال حاضر به سمت نگه داشتن یک Baby AGI هستم و از آن به عنوان یک پلتفرم برای پشتیبانی و ترویج رویکردهای مختلف گسترش استفاده میکنم (به عنوان مثال BabyAGIxLangchain به عنوان یک جهت). من معتقدم که رویکردهای نظری مختلفی وجود دارند که ارزش اکتشاف آنها را دارند، و من ارزش دارم در دسترس داشتن یک مکان مرکزی برای مقایسه و بحث بین این رویکردها را میبینم. ب
diff --git a/docs/README-fr.md b/docs/README-fr.md
new file mode 100644
index 00000000..920b6264
--- /dev/null
+++ b/docs/README-fr.md
@@ -0,0 +1,98 @@
+
+ babyagi
+
+
+# Objectif
+
+Ce script Python est un exemple de système de gestion de tâches alimenté par l'IA. Le système utilise les API OpenAI et Pinecone pour créer, hiérarchiser et exécuter des tâches. L'idée principale derrière ce système est qu'il crée des tâches en fonction du résultat des tâches précédentes et d'un objectif prédéfini. Le script utilise ensuite les capacités de traitement du langage naturel (NLP) d'OpenAI pour créer de nouvelles tâches en fonction de l'objectif, et Pinecone pour stocker et récupérer les résultats des tâches pour le contexte. Il s'agit d'une version simplifiée du [Task-Driven Autonomous Agent (Agent Autonome Piloté par les Tâches)](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 mars 2023).
+
+Ce fichier README couvrira les éléments suivants :
+
+- [Comment fonctionne le script](#how-it-works)
+
+- [Comment utiliser le script](#how-to-use)
+
+- [Les modèles pris en charge](#supported-models)
+
+- [Avertissement concernant l'exécution continue du script](#continous-script-warning)
+
+# Comment ça marche
+
+Le script fonctionne en exécutant une boucle infinie qui effectue les étapes suivantes :
+
+1. Récupère la première tâche de la liste des tâches.
+2. Envoie la tâche à l'agent d'exécution, qui utilise l'API d'OpenAI pour effectuer la tâche en fonction du contexte.
+3. Enrichit le résultat et le stocke dans Pinecone.
+4. Crée de nouvelles tâches et réorganise la liste des tâches en fonction de l'objectif et du résultat de la tâche précédente.
+
+
+La fonction `execution_agent()` est l'endroit où l'API d'OpenAI est utilisée. Elle prend deux paramètres : l'objectif et la tâche. Ensuite, elle envoie une requête à l'API d'OpenAI, qui renvoie le résultat de la tâche. La requête est constituée d'une description de la tâche du système d'IA, de l'objectif et de la tâche elle-même. Le résultat est ensuite renvoyé sous forme de chaîne de caractères.
+
+
+La fonction `task_creation_agent()` est l'endroit où l'API d'OpenAI est utilisée pour créer de nouvelles tâches en fonction de l'objectif et du résultat de la tâche précédente. La fonction prend quatre paramètres : l'objectif, le résultat de la tâche précédente, la description de la tâche et la liste des tâches actuelles. Ensuite, elle envoie une requête à l'API d'OpenAI, qui renvoie une liste de nouvelles tâches sous forme de chaînes de caractères. La fonction renvoie ensuite les nouvelles tâches sous forme d'une liste de dictionnaires, où chaque dictionnaire contient le nom de la tâche.
+
+
+La fonction `prioritization_agent()` est l'endroit où l'API d'OpenAI est utilisée pour réorganiser la liste des tâches. La fonction prend un paramètre, l'ID de la tâche actuelle. Elle envoie une requête à l'API d'OpenAI, qui renvoie la liste des tâches réorganisée sous forme d'une liste numérotée.
+
+Enfin, le script utilise Pinecone pour stocker et récupérer les résultats des tâches pour le contexte. Le script crée un index Pinecone basé sur le nom de la table spécifié dans la variable YOUR_TABLE_NAME. Pinecone est ensuite utilisé pour stocker les résultats de la tâche dans l'index, ainsi que le nom de la tâche et tout métadonnées supplémentaires.
+
+# Comment l'utiliser
+
+Pour utiliser le script, vous devrez suivre les étapes suivantes :
+
+1. Clonez le dépôt en utilisant la commande `git clone https://github.com/yoheinakajima/babyagi.git` et allez dans le répertoire cloné avec la commande `cd babyagi`.
+2. Installez les packages requis : `pip install -r requirements.txt`.
+3. Copiez le fichier .env.example en .env : cp .env.example .env. C'est là que vous définirez les variables suivantes.
+4. Définissez vos clés d'API OpenAI et Pinecone dans les variables OPENAI_API_KEY, OPENAPI_API_MODEL et PINECONE_API_KEY.
+5. Définissez l'environnement Pinecone dans la variable PINECONE_ENVIRONMENT.
+6. Définissez le nom de la table où les résultats de la tâche seront stockés dans la variable TABLE_NAME.
+7. (Optionnel) Définissez l'objectif du système de gestion de tâches dans la variable OBJECTIVE.
+8. (Optionnel) Définissez la première tâche du système dans la variable INITIAL_TASK.
+9. Exécutez le script.
+
+Toutes les valeurs facultatives ci-dessus peuvent également être spécifiées en ligne de commande.
+
+# Exécution à l'intérieur d'un conteneur Docker.
+
+Assurez-vous d'avoir docker et docker-compose installés. Docker Desktop est l'option la plus simple https://www.docker.com/products/docker-desktop/.
+
+Pour exécuter le système à l'intérieur d'un conteneur Docker, configurez votre fichier .env comme indiqué dans les étapes ci-dessus, puis exécutez ce qui suit :
+
+```
+docker-compose up
+```
+
+# Les modèles pris en charge
+
+Ce script fonctionne avec tous les modèles OpenAI, ainsi qu'avec Llama via Llama.cpp. Le modèle par défaut est gpt-3.5-turbo. Pour utiliser un modèle différent, spécifiez-le via OPENAI_API_MODEL ou utilisez la ligne de commande.
+
+## Llama
+
+Téléchargez la dernière version de [Llama.cpp](https://github.com/ggerganov/llama.cpp) puis suivez les instructions pour la compiler. Vous aurez également besoin des données pour allimenter le modèle Llama.
+
+- **Ne partagez sous saucun prétexte des liens IPFS, des liens magnet ou tout autre lien de téléchargement de modèles nulle part dans ce dépôt, y compris dans la section 'Issues', les discussions ou les 'pull request'. Ils seront immédiatement supprimés.**
+
+Après cela, liez `llama/main` à `llama.cpp/main` et `models` au dossier où vous avez données du modèle Llama. Ensuite, exécutez le script avec `OPENAI_API_MODEL=llama` ou l'argument `-l`.
+
+# Avertissement
+
+Ce script est conçu pour être exécuté en continu dans le cadre d'un système de gestion de tâches. L'exécution continue de ce script peut entraîner une utilisation élevée de l'API, veuillez donc l'utiliser de manière responsable. De plus, le script nécessite que les API OpenAI et Pinecone soient correctement configurées, veuillez donc vous assurer d'avoir configuré les API avant d'exécuter le script.
+
+# Contribution
+
+Il va sans dire que BabyAGI en est à ses débuts et que nous sommes donc en train de déterminer sa direction et les étapes à suivre. Actuellement, un objectif de conception clé pour BabyAGI est d'être simple de manière à ce qu'il soit facile à comprendre et à développer. Pour maintenir cette simplicité, nous vous demandons gentiment de respecter les directives suivantes lorsque vous soumettez des PR :
+
+- Concentrez-vous sur des modifications modulaires et petites plutôt que sur des changements (refactoring) importants.
+- Lorsque vous implémentez de nouvelles fonctionnalités, fournissez une description détaillée du cas d'utilisation spécifique que vous voulez adresser.
+
+Une note de @yoheinakajima (Apr 5th, 2023):
+
+> Je sais qu'il y a de plus en plus de pull requests, j'apprécie votre patience - étant donné que je suis nouveau sur GitHub/OpenSource et que je n'ai pas planifié correctement ma disponibilité cette semaine. En ce qui concerne l'orientation, j'ai été tiraillé entre la volonté de maintenir la simplicité de BabyAGI et celle de l'étendre - je penche actuellement pour la première option, en gardant un noyau central simple pour BabyAGI et en utilisant cela comme une plate-forme pour soutenir et promouvoir différentes approches d'expansion (par exemple, BabyAGIxLangchain comme une direction possible). Je crois qu'il existe différentes approches argumentées qui valent la peine d'être explorées, et je vois de la valeur dans le fait d'avoir un lieu central pour les comparer et en discuter. Plus de mises à jour à venir sous peu.
+
+Je suis nouveau sur GitHub et l'open source, donc veuillez être patient pendant que j'apprends à gérer ce projet correctement. Je dirige une entreprise de capital-risque le jour, donc je vérifierai généralement les PRs et Issues le soir après avoir couché mes enfants - ce qui ne sera peut-être pas tous les soirs. Je suis ouvert à l'idée d'apporter un soutien, je mettrai bientôt à jour cette section (attentes, visions, etc.). Je parle à beaucoup de gens et j'apprends - restez à l'écoute pour les mises à jour !
+
+# Contexte
+
+BabyAGI est a une version simplifiée du [Task-Driven Autonomous Agent (Agent Autonome Piloté par les Tâches)](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 mars 2023) partagé sur Twitter. Cette version ne contient plus que 140 lignes : 13 commentaires, 22 espaces, et 105 lignes de code. Le nom du référentiel est apparu en réaction à l'agent autonome original - l'auteur ne veut pas impliquer que ceci est un AGI.
+
+Fait avec amour par [@yoheinakajima](https://twitter.com/yoheinakajima), qui se trouve être un investisseur (j'aimerais voir ce sur quoi vous travaillez !)
\ No newline at end of file
diff --git a/docs/README-hu.md b/docs/README-hu.md
new file mode 100644
index 00000000..87356e79
--- /dev/null
+++ b/docs/README-hu.md
@@ -0,0 +1,111 @@
+# További fordítások:
+
+[](./README-fr.md)
+[](./README-pt-br.md)
+[](./README-ro.md)
+[](./README-ru.md)
+[](./README-si.md)
+[](./README-es.md)
+[](./README-tr.md)
+[](./README-ua.md)
+[](./README-cn.md)
+[](./README-zh-tw.md)
+[](./README-ja.md)
+
+# Célkitűzés
+
+Ez a Python szkript egy AI-alapú feladatkezelő rendszer példája. A rendszer az OpenAI és a Pinecone API-kat használja feladatok létrehozásához, prioritizálásához és végrehajtásához. A rendszer fő ötlete az, hogy a korábbi feladatok eredményeire és egy előre meghatározott célokra alapozva hozza létre az új feladatokat. A szkript az OpenAI természetes nyelvfeldolgozási (NLP) képességeit használja feladatok létrehozásához, és a Pinecone-t tárolja és visszakeresi a feladatok eredményeit a kontextus miatt. Ez egy lecsupaszított változata az eredeti [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (2023. március 28.) programnak.
+
+Ez az OLVASSEL a következőket foglalja magába:
+
+- [Hogyan működik?](#how-it-works)
+
+- [Hogyan használható?](#how-to-use)
+
+- [Támogatott modellek](#supported-models)
+
+- [Figyelmeztetés a folyamatos futtatásra vonatkozóan](#continous-script-warning)
+
+# Hogyan működik
+
+A szkript egy végtelen ciklus futtatásával működik, amely a következő lépéseket hajtja végre:
+
+ 1. Lekéri az első feladatot a feladatlistából.
+ 2. Elküldi a feladatot a végrehajtó ügynöknek, amely az OpenAI API-ját használja a feladat teljesítéséhez a kontextus alapján.
+ 3. Gazdagítja az eredményt, majd tárolja a Pinecone-ban.
+ 4. Új feladatokat hoz létre és prioritást állít be a feladatlista alapján az objektív és az előző feladat eredménye szerint.
+
+
+A "execution_agent()" funkcióban használjuk az OpenAI API-t ami két paramétert adunk meg: az objektumot és a feladatot. Ezután küld egy lekérdezést az OpenAI API-jához, ami visszaadja az utasítás eredményét. Az lekérdezésre kerülő utasítás tartalmazza az AI rendszer feladatának leírását, az objektumot és magát a feladatot. A választ egy String formátumban kapjuk vissza.
+
+A "task_creation_agent()" funkcióban az OpenAI API-ját használjuk új lekérdezések és az azokhoz tartozó utasítások létrehozásához az objektum és az előző feladat eredménye alapján. A funkció négy paramétert vár: az objektumot, az előző feladat eredményét, a feladat leírását és a jelenlegi feladatlistát. Ezután küld egy lekérdezést az újonnan létrehozott utasítással az OpenAI API-jához, ami válaszként egy új feladatokból álló listával válaszol szintén String formátumban. A függvény ezután az új feladatokat szótárlistaként adja vissza, ahol minden szótár tartalmazza a feladat nevét.
+
+A "prioritization_agent()" funkcióban az OpenAI API-ját használjuk a feladatlista prioritizálásához. A funkció egy paramétert vár, ami az aktuális feladat azonosítója. Küld egy lekérdezést az OpenAI API-jához az utasítással, ami válaszként a prioritizált feladatlistát adja vissza számozva.
+
+Végül a szkript használja a Pinecone-t a feladat eredményeinek tárolásához és lekérdezéséhez a kontextusban. A script egy Pinecone indexet hoz létre a YOUR_TABLE_NAME változóban a megadott tábla alapján. A Pinecone ezután a feladat eredményeinek az indexben való tárolására szolgál, a feladat nevével és a további metaadatokkal együtt.
+
+# Hogyan használható?
+
+A szkript használatához kövesse a következő lépéseket:
+
+1. Klónozza a tárat a `git clone https://github.com/yoheinakajima/babyagi.git` majd a `cd` parancs segítségével lépjen a klónozott tároló mappájába.
+2. Telepítse a szükséges csomagokat: `pip install -r requirements.txt`
+3. Másolja az .env.example fájlt a .env fájlba: `cp .env.example .env`. Itt állíthatja be a következőkben megadott változókat.
+4. Állítsa be az OpenAI és Pinecone API-kulcsokat az OPENAI_API_KEY, OPENAPI_API_MODEL és PINECONE_API_KEY változókban.
+5. Állítsa be a Pinecone környezetet a PINECONE_ENVIRONMENT változóban.
+6. Adja meg a TABLE_NAME változóban annak a táblának a nevét, ahol a feladat eredményeit tárolni fogja.
+7. (Opcionális) Állítsa be a feladatkezelő rendszer célját az OBJEKTÍV változóban.
+8. (Opcionális) Állítsa be a rendszer első feladatát az INITIAL_TASK változóban.
+9. Futtassa a szkriptet.
+
+Az összes fenti opcionális érték a parancssorban is megadható.
+
+
+# Futtatás Docker konténeren
+
+Előfeltételként telepítenie kell a `docker`-t és a `docker-compose`-t, ha még nem rendelkezik ezekkel. A Docker asztali verziója a legegyszerűbb lehetőség ezeknek a telepítéséhez https://www.docker.com/products/docker-desktop/
+
+A rendszer docker-tárolón belüli futtatásához állítsa be az `.env` fájlt a fenti lépések szerint, majd futtassa a következőket:
+
+```
+docker-compose up
+```
+
+# Támogatott modellek
+
+Ez a szkript minden OpenAI modellel működik, valamint a Llama.cpp-n keresztül a Llamával is. Az alapértelmezett modell a **gpt-3.5-turbo**. Másik modell használatához adja meg az OPENAI_API_MODEL segítségével, vagy használja a parancssort.
+
+## Llama
+
+Töltse le a [Llama.cpp](https://github.com/ggerganov/llama.cpp) legújabb verzióját, és kövesse az utasításokat az elkészítéséhez. Szükséged lesz a Llama modellsúlyokra is.
+
+- **Semmilyen körülmények között ne ossza meg az IPFS-t, a mágneses hivatkozásokat vagy a modellletöltésekhez vezető más hivatkozásokat sehol ebben a tárhelyben, beleértve a problémákat, a vitákat vagy a lekérési kéréseket mert azok azonnal törlődnek.**
+
+Ezután kapcsolja össze a `llama/main`-t a llama.cpp/main-hez, a `models`-t pedig ahhoz a mappához, ahol a Llama-modell súlyai vannak. Ezután futtassa a szkriptet `OPENAI_API_MODEL=llama` vagy `-l` argumentummal.
+
+# Figyelmeztetés
+
+Ezt a szkriptet úgy tervezték, hogy a feladatkezelő rendszer részeként folyamatosan futhasson. A szkript folyamatos futtatása magas API-használatot eredményezhet, ezért kérjük, használja felelősségteljesen! Ezenkívül a szkript megköveteli az OpenAI és Pinecone API-k megfelelő beállítását, ezért a szkript futtatása előtt győződjön meg arról, hogy megfelelően beállította a szükséges API-kra vonatkozó beállításokat.
+
+# Hozzájárulás
+
+Mondanunk sem kell, hogy a BabyAGI még gyerekcipőben jár, ezért még mindig meg kell határozzuk a szkript irányát és a lépéseit. Jelenleg a BabyAGI legfontosabb tervezési célja, hogy _egyszerű_, _könnyen érthető_ és _építhető_ legyen. Az egyszerűség megőrzése érdekében kérjük, hogy a PR-ok benyújtásakor tartsa be az alábbi irányelveket:
+
+- A kiterjedt átalakítás helyett a kis, moduláris módosításokra összpontosítson.
+- Új funkciók bevezetésekor részletes leírást adjon az Ön által kezelt konkrét használati esetről.
+
+Egy megjegyzés @yoheinakajima-tól (2023. április 5.):
+
+> I know there are a growing number of PRs, appreciate your patience - as I am both new to GitHub/OpenSource, and did not plan my time availability accordingly this week. Re:direction, I've been torn on keeping it simple vs expanding - currently leaning towards keeping a core Baby AGI simple, and using this as a platform to support and promote different approaches to expanding this (eg. BabyAGIxLangchain as one direction). I believe there are various opinionated approaches that are worth exploring, and I see value in having a central place to compare and discuss. More updates coming shortly.
+
+I am new to GitHub and open source, so please be patient as I learn to manage this project properly. I run a VC firm by day, so I will generally be checking PRs and issues at night after I get my kids down - which may not be every night. Open to the idea of bringing in support, will be updating this section soon (expectations, visions, etc). Talking to lots of people and learning - hang tight for updates!
+
+# Inspirált projektek
+
+A megjelenés óta eltelt rövid idő alatt a BabyAGI számos projektet inspirált. Mindegyiket megtekintheti [itt](docs/inspired-projects.md).
+
+# Háttértörténet
+
+A BabyAGI a Twitteren megosztott eredeti [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) kicsinyített változata (2023. március 28.). Ez a verzió 140 soros: 13 megjegyzés, 22 üres és 105 kód. A tároló neve az eredeti autonóm ügynökre adott reakcióban merült fel – a szerző nem azt akarja sugallni, hogy ez az AGI!
+
+Szeretettel készítette [@yoheinakajima](https://twitter.com/yoheinakajima), aki nagyon szívesen látná, mit építesz!
diff --git a/docs/README-in.md b/docs/README-in.md
new file mode 100644
index 00000000..a192f32f
--- /dev/null
+++ b/docs/README-in.md
@@ -0,0 +1,100 @@
+
babyagi
+
+# Objective
+
+यह पायथन स्क्रिप्ट एक एआई-पावर्ड टास्क मैनेजमेंट सिस्टम का एक उदाहरण है। यह सिस्टम ओपेनएआई और वेक्टर डेटाबेस जैसे Chroma या Weaviate का उपयोग करता है ताकि कार्यों को बनाना, प्राथमिकता देना और क्रियान्वयन करना संभव हो सके। इस सिस्टम के पीछे की मुख्य विचारधारा यह है कि यह पिछले कार्यों के परिणाम और एक पूर्वनिर्धारित उद्देश्य के आधार पर कार्यों को बनाता है। फिर स्क्रिप्ट ओपेनएआई के प्राकृतिक भाषा प्रोसेसिंग (एनएलपी) क्षमताओं का उपयोग करता है ताकि उद्देश्य के आधार पर नए कार्य बनाए जा सकें, और Chroma / Weaviate का उपयोग करता है ताकि संदर्भ के लिए कार्य परिणाम संग्रहीत और पुनर्प्राप्त किए जा सकें। यह मूल [टास्क-ड्रिवन ऑटोनोमस एजेंट](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 मार्च, 2023) का एक कम किए गए संस्करण है।
+
+यह README निम्नलिखित विषयों पर चर्चा करेगा:
+
+- [स्क्रिप्ट कैसे काम करता है](#how-it-works)
+- [स्रिप्ट का उपयोग कैसे करें](#how-to-use)
+- [समर्थित मॉडल](#supported-models)
+- [स्क्रिप्ट को निरंतर चलाने के बारे में चेतावनी](#continous-script-warning)
+
+# कैसे काम करता है
+
+
+यह स्क्रिप्ट निम्नलिखित चरणों को करते हुए एक अनंत लूप को चलाकर काम करता है:
+
+1. कार्य सूची से पहला कार्य खींचें।
+2. कार्य को क्रियान्वयन एजेंट को भेजें, जो संदर्भ के आधार पर टास्क को पूरा करने के लिए ओपनएआई के एपीआई का उपयोग करता है।
+3. परिणाम को अमीर बनाकर [Chroma](https://docs.trychroma.com)/[Weaviate](https://weaviate.io/) में संग्रहीत करें।
+4. उद्देश्य और पिछले कार्य के परिणाम के आधार पर नए कार्य बनाएं और कार्य सूची की प्राथमिकता को दोबारा तैयार करें।
+
+
+
+
+`execution_agent()` फ़ंक्शन में ओपनएआई एपीआई का उपयोग किया जाता है। इसमें दो पैरामीटर होते हैं: उद्देश्य और कार्य। फिर यह ओपनएआई के एपीआई को एक प्रॉम्प्ट भेजता है, जो कार्य के परिणाम को लौटाता है। प्रॉम्प्ट में एक एआई सिस्टम के कार्य का वर्णन, उद्देश्य, और कार्य होता है। फिर परिणाम एक स्ट्रिंग के रूप में लौटाया जाता है।
+
+`task_creation_agent()` फ़ंक्शन में ओपनएआई का उपयोग उद्देश्य और पिछले कार्य के परिणाम के आधार पर नए कार्य बनाने के लिए किया जाता है। यह फ़ंक्शन चार पैरामीटर लेता है: उद्देश्य, पिछले कार्य के परिणाम, कार्य विवरण, और वर्तमान कार्य सूची। फिर यह ओपनएआई को एक प्रॉम्प्ट भेजता है, जो नए कार्यों की एक स्ट्रिंग की सूची लौटाता है। फ़ंक्शन फिर नए कार्यों को डिक्शनरी की एक सूची के रूप में लौटाता है, जहाँ प्रत्येक डिक्शनरी में कार्य का नाम होता है।
+
+
+`prioritization_agent()` फ़ंक्शन में OpenAI के API का उपयोग किया जाता है जिससे टास्क सूची को दोबारा प्राथमिकता दी जाती है। फ़ंक्शन एक पैरामीटर लेता है, वर्तमान कार्य का आईडी। यह OpenAI के API को एक प्रॉम्प्ट भेजता है, जो नंबरदार सूची के रूप में दोबारा प्राथमिकता दी गई टास्क सूची लौटाता है।
+
+अंत में, स्क्रिप्ट Chroma/Weaviate का उपयोग करता है टास्क परिणामों को संदर्भ के लिए संग्रहीत और पुनः प्राप्त करने के लिए। स्क्रिप्ट टेबल नाम में निर्दिष्ट बचाव के आधार पर एक Chroma/Weaviate संग्रह बनाता है। Chroma/Weaviate फिर संग्रह में कार्य के परिणामों को, साथ ही कार्य के नाम और किसी अतिरिक्त मेटाडेटा के साथ संग्रहीत करने के लिए उपयोग किया जाता है।
+
+# कैसे उपयोग करें
+
+स्क्रिप्ट का उपयोग करने के लिए, आपको निम्नलिखित चरणों का पालन करना होगा:
+
+1. रिपॉजिटरी क्लोन करें: `git clone https://github.com/yoheinakajima/babyagi.git` और cd कमांड का उपयोग करके क्लोन रिपॉजिटरी में जाएं।
+2. आवश्यक पैकेजों को इंस्टॉल करें: `pip install -r requirements.txt`
+3. .env.example फ़ाइल को .env में कॉपी करें: `cp .env.example .env`। यहाँ आप निम्नलिखित वेरिएबल को सेट करेंगे।
+4. अपनी OpenAI API कुंजी को OPENAI_API_KEY और OPENAPI_API_MODEL वेरिएबल में सेट करें।
+5. टेबल नाम जहाँ कार्य परिणाम संग्रहित होंगे, उसे TABLE_NAME वेरिएबल में सेट करें।
+6. (वैकल्पिक) BABY_NAME वेरिएबल में BabyAGI इंस्टेंस का नाम सेट करें।
+7. (वैकल्पिक) OBJECTIVE वेरिएबल में कार्य प्रबंधन प्रणाली का उद्देश्य सेट करें।
+8. (वैकल्पिक) INITIAL_TASK वेरिएबल में प्रणाली का पहला कार्य सेट करें।
+9. स्क्रिप्ट को रन करें: `python babyagi.py`
+
+ऊपर दिए गए सभी वैकल्पिक मान भी कमांड लाइन पर निर्दिष्ट किए जा सकते हैं।
+
+# डॉकर कंटेनर के भीतर चलाना
+
+पूर्वापेक्षा के रूप में, आपको डॉकर और डॉकर-कम्पोज इंस्टॉल करने की आवश्यकता होगी। डॉकर डेस्कटॉप सबसे सरल विकल्प है https://www.docker.com/products/docker-desktop/
+
+एक डॉकर कंटेनर के भीतर सिस्टम को चलाने के लिए, उपरोक्त चरणों के अनुसार अपनी .env फ़ाइल सेटअप करें और फिर निम्नलिखित को चलाएँ:
+
+```
+docker-compose up
+```
+
+# समर्थित मॉडल
+
+यह स्क्रिप्ट सभी OpenAI मॉडलों के साथ काम करता है, यहां तक कि Llama और उसके विभिन्न रूपों के साथ भी Llama.cpp के माध्यम से। डिफ़ॉल्ट मॉडल **gpt-3.5-turbo** है। किसी भी अन्य मॉडल का उपयोग करने के लिए, LLM_MODEL के माध्यम से इसे निर्दिष्ट करें या कमांड लाइन का उपयोग करें।
+
+## Llama
+
+Llama एकीकरण के लिए llama-cpp पैकेज की आवश्यकता होगी। आपको भी Llama मॉडल वेट्स की आवश्यकता होगी।
+
+- **किसी भी स्थिति में इस रेपो में, जिसमें मॉडल डाउनलोड के लिंक, जैसे IPFS, मैग्नेट लिंक या कोई भी दूसरा लिंक हो, उन्हें मुंहतोड़ रूप से हटा दिया जाएगा। इनका उपयोग करने वालों को तुरंत निष्कासित किया जाएगा।**
+
+एक बार जब आप उन्हें प्राप्त कर लेते हैं, तो LLAMA_MODEL_PATH में निर्दिष्ट मॉडल के पथ को सेट करें। सुविधा के लिए, आप `models` को BabyAGI repo में जहां आपके पास Llama मॉडल वेट्स हैं, उस फ़ोल्डर से लिंक कर सकते हैं। फिर `LLM_MODEL=llama` या `-l` तर्क के साथ स्क्रिप्ट चल
+
+# चेतावनी
+
+यह स्क्रिप्ट एक कार्य प्रबंधन सिस्टम के रूप में निरंतर चलाने के लिए डिजाइन किया गया है। इसे निरंतर चलाने से उच्च API उपयोग हो सकता है, इसलिए कृपया इसका जिम्मेदार उपयोग करें। इसके अलावा, स्क्रिप्ट को ठीक से सेटअप करने के लिए ओपनएआई एपीआई की आवश्यकता होती है, इसलिए स्क्रिप्ट को चलाने से पहले ओपनएआई एपीआई को सेटअप करने की सुनिश्चित करें।
+
+# योगदान
+
+निश्चित रूप से, बेबीएजी अभी अपनी शुरुआती अवस्था में है और इस दिशा और उस तक पहुंचने के लिए आवश्यक कदम अभी तक निर्धारित नहीं हुए हैं। वर्तमान में, बेबीएजी के लिए एक महत्वपूर्ण डिजाइन लक्ष्य है कि यह _सरल_ होना चाहिए ताकि इसे समझना और उस पर निर्माण करना आसान हो। इस सरलता को बनाए रखने के लिए, जब आप PR जमा करते हैं, तो कृपया निम्नलिखित दिशानिर्देशों का पालन करें:
+
+- बड़े, विस्तृत रीफैक्टरिंग की जगह छोटे, मॉड्यूलर संशोधनों पर ध्यान केंद्रित करें।
+- नई सुविधाओं को लाने के समय, आपको उस विशिष्ट उपयोग मामले का विस्तृत विवरण प्रदान करना चाहिए।
+
+@yoheinakajima से एक नोट (5 अप्रैल, 2023):
+
+> मुझे पता है कि GitHub और ओपन सोर्स के बढ़ते हुए नंबर से मैंने अपने समय की उपलब्धता के अनुसार प्लान नहीं बनाया है - इसलिए आपकी सहनशीलता की कामना करता हूं। संबंधित दिशा में, मैं सरल रखने या विस्तार करने के बीच उलझा हुआ हूँ - वर्तमान में बेबी एजीआई कोर सरल रखने की ओर झुका हुआ हूँ, और इसे एक मंच के रूप में उपयोग करके इसे विस्तारित करने के विभिन्न दिशाओं का समर्थन और प्रचार करने के लिए (जैसे BabyAGIxLangchain एक दिशा हो सकती है)। मुझे लगता है कि विभिन्न मतभेदग्रस्त दृष्टिकोण हैं जो अन्वेषण के लायक हैं, और मुझे इसमें एक केंद्रीय स्थान का महत्व देखने में है जहां तुलना और चर्चा की जा सकती है। जल्द ही और अद्यतन आ रहे हैं।
+
+मैं GitHub और ओपन सोर्स में नया हूँ, इसलिए कृपया मुझे इस प्रोजेक्ट को सही ढंग से प्रबंधित करना सीखने के लिए संयम रखें। मैं दिनभर VC फर्म चलाता हूँ, इसलिए अधिकतम समय मैं अपने बच्चों को सोने के बाद रात में PRs और इश्यूज की जाँच करूँगा - जो हर रात नहीं हो सकता है। मैं सहायता लाने की विचारधारा को खुली छोड़ता हूँ, जल्द ही इस खंड को अपडेट करूंगा (अपेक्षाएं, दृष्टियाँ आदि)। मैं लोगों से बातचीत कर रहा हूँ और सीख रहा हूँ - अपडेट के लिए धैर्य रखें!
+
+# प्रेरित प्रोजेक्ट
+
+BabyAGI को रिलीज होने के कुछ ही समय में, इसने कई प्रोजेक्ट्स को प्रेरित किया है। आप उन सभी प्रोजेक्ट्स को [यहाँ](docs/inspired-projects.md) देख सकते हैं।
+
+# पूर्वकथा
+
+बेबीएजीआई ट्विटर पर साझा किए गए मूल [टास्क-ड्राइवन ऑटोनोमस एजेंट](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) का एक संस्कार वाला संस्करण है। यह संस्करण 140 लाइनों तक डाउन है: 13 टिप्पणियाँ, 22 रिक्तियां, और 105 कोड। रेपो का नाम मूल ऑटोनोमस एजेंट के प्रति प्रतिक्रिया में उठा था - लेखक इस बात का अर्थ नहीं करना चाहता कि यह एजीआई है।
+
+[@yoheinakajima](https://twitter.com/yoheinakajima) ने प्यार से बनाया है, जो एक वीसी है (अगर आप क्या बना रहे हैं, देखना चाहेंगे!)।
+
diff --git a/docs/README-ja.md b/docs/README-ja.md
new file mode 100644
index 00000000..c67e98ee
--- /dev/null
+++ b/docs/README-ja.md
@@ -0,0 +1,105 @@
+# 翻訳:
+
+[](docs/README-fr.md)
+[](docs/README-pt-br.md)
+[](docs/README-ro.md)
+[](docs/README-ru.md)
+[](docs/README-si.md)
+[](docs/README-es.md)
+[](docs/README-tr.md)
+[](docs/README-ua.md)
+[](docs/README-cn.md)
+[](docs/README-zh-tw.md)
+
+# 目的
+
+このPythonスクリプトは、AIを活用したタスク管理システムの一例です。このシステムは、OpenAIとPinecone APIを使用して、タスクの作成、優先順位付け、および実行を行います。このシステムの主な考え方は、以前のタスクの結果と事前に定義された目的に基づいてタスクを作成することです。その後、スクリプトはOpenAIの自然言語処理（NLP）機能を使って目的に基づいて新しいタスクを作成し、Pineconeでタスクの結果を保存してコンテキストを取得する。これは、オリジナルの[Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023)の縮小版です。
+
+このREADMEでは、次のことを説明します:
+
+- [スクリプトの動作について](#スクリプトの動作について)
+
+- [スクリプトの使用方法について](#使用方法について)
+
+- [サポートされるモデル](#サポートされるモデル)
+
+- [スクリプトの連続実行に関する警告](#連続使用スクリプト警告)
+
+# 仕組みについて
+
+このスクリプトは、以下のステップを実行する無限ループによって動作します:
+
+1. タスクリストから最初のタスクを引き出します。
+2. タスクを実行エージェントに送り、実行エージェントは OpenAI の API を使用して、コンテキストに基づいてタスクを完了させる。
+3. 結果をエンリッチし、Pinecone に保存する。
+4. 新しいタスクを作成し、目的と前のタスクの結果に基づいて、タスクリストを再優先化する。
+
+
+execution_agent() 関数は、OpenAI API が使用される場所です。この関数は、目的とタスクという2つのパラメータを受け取ります。そして、OpenAI の API にプロンプトを送信し、タスクの結果を返します。プロンプトは、AI システムのタスクの説明、目的、タスクそのものから構成されています。そして、結果は文字列として返されます。
+
+task_creation_agent() 関数は、OpenAI の API を使用して、目的と前のタスクの結果に基づいて、新しいタスクを作成するところです。この関数は、目的、前のタスクの結果、タスクの説明、現在のタスクリストという4つのパラメータを受け取ります。そして、OpenAI の API にプロンプトを送信し、新しいタスクのリストを文字列として返します。そして、この関数は、新しいタスクを辞書のリストとして返し、各辞書にはタスクの名前が含まれています。
+
+prioritization_agent() 関数は、OpenAI の API を使用して、タスクリストの再優先順位を決定するところです。この関数は、現在のタスクの ID を1つのパラメータとして受け取ります。OpenAI の API にプロンプトを送信し、再優先化されたタスクリストを番号付きリストとして返します。
+
+最後に、スクリプトは Pinecone を使用して、コンテキストのためにタスクの結果を保存および取得します。スクリプトは YOUR_TABLE_NAME 変数で指定されたテーブル名に基づいて Pinecone のインデックスを作成します。そして、Pinecone を使用して、タスクの結果をタスク名と追加のメタデータと一緒にインデックスに格納します。
+
+# 使用方法について
+
+スクリプトを使用するには、次の手順が必要です:
+
+1. `git clone https://github.com/yoheinakajima/babyagi.git` でリポジトリをクローンし、クローンしたリポジトリに `cd` を入れる。
+2. 必要なパッケージをインストールします： `pip install -r requirements.txt` を実行します。
+3. .env.example ファイルを .env にコピーします： `cp .env.example .env`。ここで、以下の変数を設定します。
+4. OPENAI_API_KEY、OPENAPI_API_MODEL、PINECONE_API_KEY 変数に、OpenAI と Pinecone API キーを設定します。
+5. PINECONE_ENVIRONMENT 変数に Pinecone の環境を設定します。
+6. TABLE_NAME 変数にタスクの結果を保存するテーブルの名前を設定します。
+7. （オプション）OBJECTIVE 変数にタスク管理システムの目的を設定します。
+8. （オプション）INITIAL_TASK 変数に、システムの最初のタスクを設定する。
+9. スクリプトを実行する。
+
+上記のすべてのオプション値は、コマンドラインで指定することも可能です。
+
+# Docker コンテナ内での実行
+
+前提条件として、docker と docker-compose がインストールされている必要があります。Docker desktop は最もシンプルなオプションです https://www.docker.com/products/docker-desktop/
+
+Docker コンテナ内でシステムを実行するには、上記の手順で .env ファイルを設定し、以下を実行します:
+
+```
+docker-compose up
+```
+
+# サポートされるモデル
+
+このスクリプトは、OpenAI の全モデルと、Llama.cpp を介した Llama で動作します。デフォルトのモデルは **gpt-3.5-turbo** です。別のモデルを使用するには、OPENAI_API_MODEL で指定するか、コマンドラインを使用します。
+
+## Llama
+
+最新版の [Llama.cpp](https://github.com/ggerganov/llama.cpp) をダウンロードし、指示に従って作成してください。また、Llama モデルのウェイトが必要です。
+
+- **いかなる場合においても、IPFS、マグネットリンク、またはモデルダウンロードへのその他のリンクを、このリポジトリのいかなる場所（issue、discussion または pull request を含む）でも共有しないでください。それらは即座に削除されます。**
+
+その後、`llama/main` を llama.cpp/main に、`models` を Llama モデルのウェイトが入っているフォルダにリンクします。そして、`OPENAI_API_MODEL=llama` または `-l` 引数をつけてスクリプトを実行します。
+
+# 警告
+
+このスクリプトは、タスク管理システムの一部として連続的に実行されるように設計されています。このスクリプトを連続的に実行すると、API の使用量が多くなることがありますので、責任を持って使用してください。さらに、このスクリプトは OpenAI と Pinecone の API が正しく設定されている必要がありますので、スクリプトを実行する前に API の設定が完了していることを確認してください。
+
+# コントリビュート
+
+言うまでもなく、BabyAGI はまだ初期段階にあり、その方向性とそこに到達するためのステップを決定しているところです。現在、BabyAGI が目指しているのは、「シンプル」であることです。このシンプルさを維持するために、PR を提出する際には、以下のガイドラインを遵守していただくようお願いいたします:
+
+- 大規模なリファクタリングではなく、小規模でモジュール化された修正に重点を置く。
+- 新機能を導入する際には、対応する特定のユースケースについて詳細な説明を行うこと。
+
+@yoheinakajima (2023年4月5日)からのメモ:
+
+> 私は GitHub/OpenSource の初心者で、今週は時間的な余裕を計画できていなかったので。現在、Baby AGI のコアをシンプルに保ち、これをプラットフォームとして拡張するためのさまざまなアプローチをサポートし、促進することに傾いています（例えば、BabyAGIxLangchain は一つの方向性です）。私は探求する価値のある様々な意見のアプローチがあると信じていますし、比較し議論するための中心的な場所を持つことに価値があると考えています。近日中にもっと更新します。
+
+私は GitHub とオープンソースに慣れていないので、このプロジェクトを適切に管理できるようになるまで辛抱してください。昼間は VC 会社を経営しているので、PR や issue のチェックはだいたい夜、子供たちを寝かしつけた後に行うことになります（毎晩とは限りませんが）。サポートが必要な場合は、近日中にこのセクションを更新する予定です（期待、ビジョンなど）。多くの人と話し、学んでいます！
+
+# 裏話
+
+BabyAGI は、Twitter でシェアされたオリジナルの [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) を縮小したバージョンです。このバージョンは140行に減っています： コメント13行、空白22行、コード105行です。このリポジトリの名前は、オリジナルの自律型エージェントに対する反応から生まれたもので、作者はこれが AGI であることを意味するものではありません。
+
+偶然にも VC である [@yoheinakajima](https://twitter.com/yoheinakajima) が愛を込めて作っています（みなさんの作っている物も見せてください！）。
diff --git a/docs/README-ko.md b/docs/README-ko.md
new file mode 100644
index 00000000..e20e8588
--- /dev/null
+++ b/docs/README-ko.md
@@ -0,0 +1,103 @@
+# Translations:
+
+[](docs/README-fr.md)
+[](docs/README-pt-br.md)
+[](docs/README-ro.md)
+[](docs/README-ru.md)
+[](docs/README-si.md)
+[](docs/README-es.md)
+[](docs/README-tr.md)
+[](docs/README-ua.md)
+[](docs/README-cn.md)
+[](docs/README-zh-tw.md)
+[](docs/README-ja.md)
+[](docs/README-ko.md)
+
+# 목표
+이 Python 스크립트는 AI 기반 작업 관리 시스템의 예시입니다. 이 시스템은 OpenAI 및 Pinecone API를 사용하여 작업을 생성하고, 우선순위를 지정하고, 실행합니다. 이 시스템의 기본 아이디어는 이전 작업의 결과와 미리 정의된 목표를 기반으로 작업을 생성한다는 것입니다. 그런 다음 스크립트는 OpenAI의 자연어 처리(NLP) 기능을 사용하여 목표에 따라 새 작업을 생성하고 Pinecone은 컨텍스트에 맞게 작업 결과를 저장 및 검색합니다. 이것은 원래의 [작업 기반 자율 에이전트](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (2023년 3월 28일)를 축소한 버전입니다.
+
+이 README에서는 다음 내용을 다룹니다:
+
+* [스크립트 작동 방식](#how-it-works)
+
+* [스크립트 사용 방법](#how-to-use)
+
+* [지원되는 모델](#supported-models)
+
+* [스크립트 연속 실행에 대한 경고](#continuous-script-warning)
+# 작동 방식
+스크립트는 다음 단계를 수행하는 무한 루프를 실행하여 작동합니다:
+
+1. 작업 목록에서 첫 번째 작업을 가져옵니다.
+2. 실행 에이전트로 작업을 전송하고, 실행 에이전트는 OpenAI의 API를 사용하여 컨텍스트에 따라 작업을 완료합니다.
+3. 결과를 보강하여 Pinecone에 저장합니다.
+4. 새 작업을 생성하고 목표와 이전 작업의 결과에 따라 작업 목록의 우선순위를 다시 지정합니다.
+
+execution_agent() 함수는 OpenAI API가 사용되는 곳입니다. 이 함수는 목표와 작업이라는 두 가지 매개 변수를 받습니다. 그런 다음 OpenAI의 API에 프롬프트를 전송하여 작업의 결과를 반환합니다. prompt는 AI 시스템의 작업, 목표 및 작업 자체에 대한 설명으로 구성됩니다. 그런 다음 결과는 문자열로 반환됩니다.
+
+task_creation_agent() 함수는 OpenAI의 API를 사용하여 목표와 이전 작업의 결과를 기반으로 새 작업을 생성하는 데 사용됩니다. 이 함수는 목표, 이전 작업의 결과, 작업 설명, 현재 작업 목록의 네 가지 매개 변수를 받습니다. 그런 다음 이 함수는 새 작업 목록을 문자열로 반환하는 OpenAI의 API에 프롬프트를 보냅니다. 그런 다음 이 함수는 새 작업을 사전 목록으로 반환하며, 각 사전에는 작업의 이름이 포함됩니다.
+
+prioritization_agent() 함수는 작업 목록의 우선순위를 재지정하기 위해 OpenAI의 API를 사용하는 곳입니다. 이 함수는 하나의 매개변수, 즉 현재 작업의 ID를 받습니다. 이 함수는 OpenAI의 API에 프롬프트를 전송하여 우선순위가 재지정된 작업 목록을 번호가 매겨진 목록으로 반환합니다.
+
+마지막으로, 이 스크립트는 Pinecone을 사용하여 컨텍스트에 맞는 작업 결과를 저장하고 검색합니다. 이 스크립트는 YOUR_TABLE_NAME 변수에 지정된 테이블 이름을 기반으로 Pinecone 인덱스를 생성합니다. 그런 다음 Pinecone을 사용하여 작업 결과를 작업 이름 및 추가 메타데이터와 함께 인덱스에 저장합니다.
+
+# 사용 방법
+스크립트를 사용하려면 다음 단계를 따라야 합니다:
+
+1. `git clone https://github.com/yoheinakajima/babyagi.git`과 `cd`를 통해 리포지토리를 복제하고 복제된 리포지토리에 저장합니다.
+2. 필요한 패키지를 설치합니다: `pip install -r requirements.txt`
+3. .env.example 파일을 .env에 복사합니다: `cp .env.example .env`. 여기에서 다음 변수를 설정합니다.
+4. OPENAI_API_KEY, OPENAPI_API_MODEL, PINECONE_API_KEY 변수에 OpenAI 및 Pinecone API 키를 설정합니다.
+5. PINECONE_ENVIRONMENT 변수에서 Pinecone 환경을 설정합니다.
+6. 작업 결과가 저장될 테이블의 이름을 TABLE_NAME 변수에 설정합니다.
+7. (선택 사항) OBJECTIVE 변수에 작업 관리 시스템의 목적을 설정합니다.
+8. (선택 사항) 시스템의 첫 번째 작업을 INITIAL_TASK 변수에 설정합니다.
+9. 스크립트를 실행합니다.
+
+위의 모든 옵션 값은 커맨드 라인에서도 지정할 수 있습니다.
+
+# 도커 컨테이너로 실행하기
+
+전제 조건으로 도커와 도커-컴포즈가 설치되어 있어야 합니다. Docker 데스크톱이 가장 간단한 옵션입니다(https://www.docker.com/products/docker-desktop/).
+
+도커 컨테이너로 시스템을 실행하려면 위의 단계에 따라 .env 파일을 설정한 다음 다음을 실행합니다:
+
+```
+docker-compose up
+```
+
+# 지원되는 모델
+
+이 스크립트는 모든 OpenAI 모델과 Llama.cpp를 통한 Llama에서 작동합니다. 기본 모델은 **gpt-3.5-turbo**입니다. 다른 모델을 사용하려면 OPENAI_API_MODEL을 통해 지정하거나 커맨드 라인을 사용하세요.
+
+## Llama
+
+최신 버전의 [Llama.cpp](https://github.com/ggerganov/llama.cpp)를 다운로드하고 지침에 따라 제작하세요. 또한 Llama 모델 추가 필요합니다.
+
+- **어떠한 경우에도 이슈, 토론 또는 풀 리퀘스트를 포함하여 이 리포지토리의 어느 곳에서도 IPFS, 마그넷 링크 또는 모델 다운로드에 대한 기타 링크를 공유해서는 안 됩니다. 즉시 삭제됩니다.**
+
+그 후 `llama/main`을 llama.cpp/main에 연결하고 `models`을 Llama 모델 가중치가 있는 폴더에 연결합니다. 그런 다음 `OPENAI_API_MODEL=llama` 또는 `-l` 인수를 사용하여 스크립트를 실행합니다.
+
+# 경고
+이 스크립트는 작업 관리 시스템의 일부로서 계속적으로 실행되도록 디자인되었습니다. 이 스크립트를 계속 실행하면 API 사용량이 높아질 수 있으므로 책임감 있게 사용하시기 바랍니다. 또한 이 스크립트를 실행하려면 OpenAI 및 Pinecone API가 올바르게 설정되어 있어야 하므로 스크립트를 실행하기 전에 API를 설정했는지 확인하세요.
+
+# 기여
+말할 필요도 없이, BabyAGI는 아직 초기 단계에 있으므로 아직 방향과 단계를 결정하고 있습니다. 현재 BabyAGI의 핵심 설계 목표는 이해하기 쉽고 구축하기 쉽도록 *단순하게* 만드는 것입니다. 이러한 단순성을 유지하기 위해 PR을 제출할 때 다음 가이드라인을 준수해 주시기 바랍니다:
+
+* 광범위한 리팩토링보다는 소규모의 모듈식 수정에 집중하세요.
+* 새로운 기능을 소개할 때는 구체적인 사용 사례에 대한 자세한 설명을 제공하세요.
+
+[@yoheinakajima](https://twitter.com/yoheinakajima)의 메모 (Apr 5, 2023):
+
+> PR이 점점 많아지고 있다는 것을 알고 있습니다. 저는 GitHub/오픈소스를 처음 접했고, 이번 주에는 그에 따라 시간 계획을 세우지 못했습니다. 기다리고 양해해 주셔서 감사합니다. 방향에 대해 말씀드리자면, 저는 단순하게 유지하는 것과 확장하는 것 사이에서 갈등을 겪어왔습니다. 현재는 BabyAGI의 코어를 단순하게 유지하고, 이를 플랫폼으로 삼아 이를 확장하기 위한 다양한 접근 방식을 지원하고 홍보하는 방향으로 기울고 있습니다(예: BabyAGIxLangchain이 하나의 방향입니다). 저는 탐구할 가치가 있는 다양한 의견 접근 방식이 있다고 생각하며, 이를 비교하고 토론할 수 있는 중심적인 장소를 갖는 것이 가치가 있다고 생각합니다. 곧 더 많은 업데이트가 있을 예정입니다.
+
+저는 GitHub와 오픈소스를 처음 사용하므로 이 프로젝트를 제대로 관리하는 방법을 배우는 동안 조금만 기다려주세요. 저는 낮에는 벤처캐피털 회사를 운영하기 때문에 보통 아이들을 재운 후 밤에 PR과 이슈를 확인하고 있고, 매일 밤 확인하는 것은 아닐 수도 있습니다. 지원을 구하는 아이디어에 열려 있으며 곧 이 섹션을 업데이트할 예정입니다(기대, 비전 등). 많은 사람들과 이야기를 나누며 배우고 있으니 업데이트를 기대해주세요!
+
+# 영감을 받은 프로젝트
+
+출시 이후 짧은 시간 동안 BabyAGI는 많은 프로젝트에 영감을 주었습니다. [여기](docs/inspired-projects.md)에서 모두 확인할 수 있습니다.
+
+# 배경 스토리
+BabyAGI는 트위터에 공유된 원본 [작업 기반 자율 에이전트](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20)(2023년 3월 28일)의 축소 버전입니다. 이 버전은 140줄로 줄었습니다: 주석 13줄, 공백 22줄, 코드 105줄입니다. 이 리포지토리의 이름은 오리지널 자율 에이전트에 대한 반응에서 나온 것으로, 작성자가 이것이 AGI라는 것을 암시하려는 의도는 아닙니다.
+
+벤처캐피털리스트인 [@yoheinakajima](https://twitter.com/yoheinakajima)가 애정을 담아 만들었습니다(여러분이 만들고 있는 것을 보고 싶습니다!).
\ No newline at end of file
diff --git a/docs/README-pl.md b/docs/README-pl.md
new file mode 100644
index 00000000..648d45eb
--- /dev/null
+++ b/docs/README-pl.md
@@ -0,0 +1,96 @@
+# Cel
+
+Ten skrypt Pythona jest przykładem systemu zarządzania zadaniami napędzanego przez AI. System wykorzystuje API OpenAI i Pinecone do tworzenia zadań, ustalania ich priorytetów i wykonywania. Główną ideą tego systemu jest to, że tworzy on zadania na podstawie wyników poprzednich zadań i predefiniowanego celu. Następnie skrypt wykorzystuje możliwości OpenAI w zakresie przetwarzania języka naturalnego (NLP) do tworzenia nowych zadań w oparciu o cel, a Pinecone do przechowywania i pobierania wyników zadań w kontekście. Jest to okrojona wersja oryginalnego [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 marca 2023).
+
+W tym README zostaną omówione następujące kwestie:
+
+- [Jak działa skrypt](#how-it-works)
+
+- [Jak korzystać ze skryptu](#how-to-use)
+
+- [Obsługiwane modele](#supported-models)
+
+- [Ostrzeżenie przed ciągłym działaniem skryptu](#continous-script-warning)
+
+# Jak działa skrypt
+
+Skrypt zbudowany jest w formie nieskończonej pętli, która wykonuje następujące czynności:
+
+1. Pobiera pierwsze zadanie z listy zadań.
+2. Wysyła zadanie do agenta wykonawczego, który używa API OpenAI do wykonania zadania w oparciu o kontekst.
+3. Wzbogaca wynik i zapisuje go w Pinecone.
+4. Tworzy nowe zadania i dokonuje repriorytetyzacji listy zadań w oparciu o cel i wynik poprzedniego zadania.
+
+
+Funkcja execution_agent() jest miejscem, w którym wykorzystywane jest API OpenAI. Przyjmuje ona dwa parametry: cel i zadanie. Następnie wysyła monit do API OpenAI, które zwraca wynik zadania. Zachęta składa się z opisu zadania systemu AI, celu oraz samego zadania. Wynik jest następnie zwracany jako ciąg znaków.
+
+Funkcja task_creation_agent() jest miejscem, w którym API OpenAI jest wykorzystywane do tworzenia nowych zadań na podstawie celu i wyniku poprzedniego zadania. Funkcja przyjmuje cztery parametry: cel, wynik poprzedniego zadania, opis zadania oraz aktualną listę zadań. Następnie wysyła monit do API OpenAI, które zwraca listę nowych zadań jako ciągi znaków. Następnie funkcja zwraca nowe zadania jako listę słowników, gdzie każdy słownik zawiera nazwę zadania.
+
+Funkcja prioritization_agent() jest miejscem, w którym API OpenAI jest wykorzystywane do zmiany priorytetów na liście zadań. Funkcja przyjmuje jeden parametr, ID bieżącego zadania. Wysyła ona monit do API OpenAI, które zwraca listę zadań do ponownego ustalenia priorytetów w postaci listy numerycznej.
+
+Na koniec skrypt wykorzystuje Pinecone do przechowywania i pobierania wyników zadań w kontekście. Skrypt tworzy indeks Pinecone na podstawie nazwy tabeli określonej w zmiennej YOUR_TABLE_NAME. Pinecone jest następnie używany do przechowywania wyników zadania w indeksie, wraz z nazwą zadania i wszelkimi dodatkowymi metadanymi.
+
+# Jak korzystać ze skryptu
+
+Aby skorzystać ze skryptu, należy wykonać następujące kroki:
+
+1. Sklonuj repozytorium poprzez `git clone https://github.com/yoheinakajima/babyagi.git` i przejdź (`cd`) do sklonowanego repozytorium.
+2. Zainstaluj wymagane pakiety: `pip install -r requirements.txt`.
+3. Skopiuj plik .env.example do .env: `cp .env.example .env`. W tym miejscu ustawisz następujące zmienne.
+4. Ustaw swoje klucze API OpenAI i Pinecone w zmiennych OPENAI_API_KEY, OPENAPI_API_MODEL oraz PINECONE_API_KEY.
+5. Ustaw środowisko Pinecone w zmiennej PINECONE_ENVIRONMENT.
+6. Ustaw nazwę tabeli, w której będą przechowywane wyniki zadań w zmiennej TABLE_NAME.
+7. (Opcjonalnie) Ustaw cel systemu zarządzania zadaniami w zmiennej OBJECTIVE.
+8. (Opcjonalnie) Ustaw pierwsze zadanie systemu w zmiennej INITIAL_TASK.
+9. Uruchom skrypt.
+
+Wszystkie powyższe wartości opcjonalne mogą być również określone w linii poleceń.
+
+# Uruchomienie wewnątrz kontenera docker
+
+Jako warunek wstępny, będziesz potrzebował mieć zainstalowany docker i docker-compose. Najprostszą opcją jest docker desktop: https://www.docker.com/products/docker-desktop/.
+
+Aby uruchomić system wewnątrz kontenera docker, skonfiguruj swój plik .env jak w krokach powyżej, a następnie uruchom poniższe polecenie:
+
+```
+docker-compose up
+```
+
+# Obsługiwane modele
+
+Ten skrypt działa ze wszystkimi modelami OpenAI, a także z Llama poprzez Llama.cpp. Domyślnym modelem jest **gpt-3.5-turbo**. Aby użyć innego modelu, określ go poprzez parametr OPENAI_API_MODEL lub użyj linii poleceń.
+
+## Llama
+
+Pobierz najnowszą wersję [Llama.cpp](https://github.com/ggerganov/llama.cpp) i postępuj zgodnie z instrukcjami, aby ją zbudować. Do modelu Llama będziesz również potrzebował wag.
+
+- **W żadnym wypadku nie udostępniaj IPFS, linków magnet ani żadnych innych linków do pobierania modeli w tym repozytorium, włączając w to issues, dyskusje i pull requesty. Zostaną one natychmiast usunięte.**
+
+Następnie podlinkuj `llama/main` z llama.cpp/main i `models` do folderu, w którym masz wagi modelu Llama. Następnie uruchom skrypt z argumentem `OPENAI_API_MODEL=llama` lub `-l`.
+
+# Ostrzeżenie
+
+Ten skrypt został zaprojektowany do ciągłego działania jako część systemu zarządzania zadaniami. Uruchomienie tego skryptu w trybie ciągłym może powodować duże zużycie API, więc proszę korzystać z niego w sposób odpowiedzialny. Dodatkowo, skrypt wymaga poprawnego skonfigurowania API OpenAI i Pinecone, dlatego przed uruchomieniem skryptu upewnij się, że skonfigurowałeś te API.
+
+# Twój wkład
+
+Nie trzeba dodawać, że BabyAGI jest wciąż w powijakach i dlatego wciąż określamy jego kierunek i kroki, które należy podjąć, aby go osiągnąć. Obecnie, głównym celem BabyAGI jest bycie _prostym_, tak aby było łatwe do zrozumienia i rozwijania. Aby utrzymać tę prostotę, prosimy o przestrzeganie następujących wytycznych przy wysyłaniu PR-ów:
+
+- Skup się na małych, modularnych modyfikacjach, a nie na rozległych przeróbkach / refaktoryzacji.
+- Przy wprowadzaniu nowych funkcji przedstaw szczegółowy opis konkretnego przypadku użycia, do którego się odnosisz.
+
+Uwaga od @yoheinakajima (5. kwietnia 2023):
+
+> Wiem, że jest coraz więcej PR-ów, doceniam waszą cierpliwość - jestem nowy na GitHubie/OpenSource i nie zaplanowałem odpowiednio mojego czasu w tym tygodniu. Re:kierunek, byłem rozdarty w kwestii utrzymania prostoty vs rozszerzania - obecnie skłaniam się ku utrzymaniu prostoty rdzenia Baby AGI i użyciu tego jako platformy do wspierania i promowania różnych podejść do rozszerzania tego (np. BabyAGIxLangchain jako jeden kierunek). Wierzę, że istnieją różne opiniotwórcze podejścia, które są warte zbadania i widzę wartość w posiadaniu centralnego miejsca do porównania i dyskusji. Więcej aktualizacji wkrótce.
+
+Jestem nowy w GitHubie i open source, więc proszę o cierpliwość, gdy będę się uczyć, jak prawidłowo zarządzać tym projektem. W dzień prowadzę firmę VC, więc generalnie będę sprawdzał PR-y i problemy w nocy, po tym jak zejdą mi dzieci - co może nie być codziennością. Jestem otwarty na pomysł wprowadzenia wsparcia, wkrótce będę aktualizował tę sekcję (oczekiwania, wizje, itp.). Rozmawiam z wieloma ludźmi i uczę się - czekajcie na aktualizacje!
+
+# Inne projekty zainspirowane tym projektem
+
+W krótkim czasie od premiery, BabyAGI zainspirowało wiele projektów. Możesz zobaczyć je wszystkie [tutaj](docs/inspired-projects.md).
+
+# Tło
+
+BabyAGI to okrojona wersja oryginalnego [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 marca 2023) udostępnionego na Twitterze. Ta wersja sprowadza się do 140 linii: 13 komentarzy, 22 puste miejsca i 105 kodu. Nazwa repo pojawiła się w reakcji na oryginalnego autonomicznego agenta - autor nie ma zamiaru sugerować, że jest to AGI.
+
+Wykonane z miłością przez [@yoheinakajima](https://twitter.com/yoheinakajima), który tak się składa jest też VC (chętnie zobaczyłbym, co budujesz!).
diff --git a/docs/README-pt-br.md b/docs/README-pt-br.md
new file mode 100644
index 00000000..514acb70
--- /dev/null
+++ b/docs/README-pt-br.md
@@ -0,0 +1,83 @@
+
babyagi
+
+# Objetivo
+
+Este script Python é um exemplo de um sistema de gerenciamento de tarefas orquestrado por uma IA. O sistema utiliza as APIs da OpenAI e Pinecone para criar, priorizar e executar tarefas. A ideia principal por trás deste sistema é criar tarefas com base no resultado das tarefas anteriores e em direção a um objetivo predefinido.
+
+O script usa então os recursos de processamento de linguagem natural (NLP) da OpenAI para criar novas tarefas com base no objetivo e o Pinecone para armazenar e recuperar resultados das tarefas para o contexto atual. Esta é uma versão simplificada do original [Agente Autônomo Orientado a Tarefas](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 de março de 2023).
+
+Este README abordará os seguintes tópicos:
+
+* [Como o script funciona](#como-funciona)
+
+* [Como usar o script](#como-usar)
+
+* [Modelos suportados](#modelos-suportados)
+
+* [Aviso sobre a execução contínua do script](#aviso-execucao-continua)
+
+# Como funciona
+
+Quando iniciado, o script executa um loop infinito que realiza as seguintes funçōes:
+
+1. Pega a primeira tarefa da lista de tarefas.
+2. Envia a tarefa para o agente de execução, que usa a API da OpenAI para concluir a tarefa com base no contexto.
+3. Enriquece o resultado e armazena-o no Pinecone.
+4. Cria novas tarefas e reprioriza a lista de tarefas com base no objetivo e no resultado da tarefa anterior. A função `execution_agent()` é onde a API da OpenAI é utilizada. Ela recebe dois parâmetros: o objetivo e a tarefa. Em seguida, envia um prompt para a API da OpenAI, que retorna o resultado da tarefa. O prompt consiste em uma descrição da tarefa do sistema de IA, o objetivo e a própria tarefa. O resultado é então retornado como uma string.
+
+A função `task_creation_agent()` é onde a API da OpenAI é usada para criar novas tarefas com base no objetivo e no resultado da tarefa anterior. A função recebe quatro parâmetros: o objetivo, o resultado da tarefa anterior, a descrição da tarefa e a lista de tarefas atual. Em seguida, envia um prompt para a API da OpenAI, que retorna uma lista de novas tarefas como strings. A função retorna as novas tarefas como uma lista de dicionários, onde cada dicionário contém o nome da tarefa.
+
+A função `prioritization_agent()` é onde a API da OpenAI é usada para repriorizar a lista de tarefas. A função recebe um parâmetro, o ID da tarefa atual. Envia um prompt para a API da OpenAI, que retorna a lista de tarefas repriorizada como uma lista numerada.
+
+Por fim, o script utiliza o Pinecone para armazenar e recuperar resultados de tarefas para contexto. O script cria um índice Pinecone com base no nome da tabela especificado na variável `YOUR_TABLE_NAME`. Pinecone é então usado para armazenar os resultados da tarefa no índice, juntamente com o nome da tarefa e quaisquer metadados adicionais.
+
+# Como usar
+
+Para usar o script, siga estas etapas:
+
+1. Clone o repositório via `git clone https://github.com/yoheinakajima/babyagi.git` e entre no repositório clonado.
+2. Instale os pacotes necessários: `pip install -r requirements.txt`
+3. Copie o arquivo .env.example para .env: `cp .env.example .env`. É aqui que você definirá as seguintes variáveis.
+4. Defina suas chaves de API da OpenAI e Pinecone nas variáveis `OPENAI_API_KEY`, `OPENAPI_API_MODEL` e `PINECONE_API_KEY`.
+5. Defina o ambiente Pinecone na variável `PINECONE_ENVIRONMENT`.
+6. Defina o nome da tabela onde os resultados das tarefas serão armazenados na variável `TABLE_NAME`.
+7. (Opcional) Defina o objetivo do sistema de gerenciamento de tarefas na variável `OBJECTIVE`.
+8. (Opcional) Defina a primeira tarefa do sistema na variável `INITIAL_TASK`.
+9. Execute o script.
+
+Todos os valores opcionais acima também podem ser especificados na linha de comando.
+
+# Modelos suportados
+
+Este script funciona com todos os modelos da OpenAI, bem como com Llama através do Llama.cpp. O modelo padrão é **gpt-3.5-turbo**. Para usar um modelo diferente, especifique-o através da variável de ambiente `OPENAI_API_MODEL` ou use a linha de comando.
+
+## Llama
+
+Baixe a versão mais recente do [Llama.cpp](https://github.com/ggerganov/llama.cpp) e siga as instruções para compilá-lo. Você também precisará dos pesos do modelo Llama.
+
+- **Em hipótese alguma compartilhe IPFS, links magnéticos ou quaisquer outros links para downloads de modelos em qualquer lugar neste repositório, incluindo em issues, discussões ou solicitações pull request. Eles serão imediatamente excluídos.**
+
+Depois disso, vincule `llama/main` ao llama.cpp/main e `models` à pasta onde você possui os pesos do modelo Llama. Em seguida, execute o script com `OPENAI_API_MODEL=llama` ou argumento `-l`.
+
+# Aviso
+
+Este script foi projetado para ser executado continuamente como parte de um sistema de gerenciamento de tarefas. Executar este script continuamente pode resultar em alto uso da API, o que pode acarretar em grandes custos ao usuário, então, por favor, use-o com responsabilidade. Além disso, o script requer que as APIs da OpenAI e Pinecone sejam configuradas corretamente, portanto, certifique-se de ter configurado as APIs antes de executar o script.
+
+# Contribuição
+
+Obviamente, o BabyAGI ainda está em sua infância e, portanto, ainda estamos determinando sua direção e as etapas para chegar lá. Atualmente, um objetivo-chave de design para o BabyAGI é ser *simples* de forma que seja fácil de entender e desenvolver a partir dele. Para manter essa simplicidade, pedimos gentilmente que você siga as seguintes diretrizes ao enviar PRs:
+
+- Concentre-se em modificações pequenas e modulares em vez de refatorações extensas.
+- Ao introduzir novos recursos, forneça uma descrição detalhada do caso de uso específico que você está abordando.
+
+Um recado de @yoheinakajima (5 de abril de 2023):
+
+> Eu sei que há um número crescente de PRs, agradeço sua paciência - já que sou novo no GitHub/OpenSource e não planejei adequadamente minha disponibilidade de tempo nesta semana. Re:direction Estive dividido entre manter a simplicidade e expandir - atualmente, estou inclinado a manter um Baby AGI central simples e usar isso como plataforma para apoiar e promover diferentes abordagens para expandir (por exemplo, BabyAGIxLangchain como uma direção). Acredito que existem várias abordagens que valem a pena ser exploradas, e vejo valor em ter um local central para comparar e discutir. Em breve, mais atualizações.
+
+Sou novo no GitHub e no código aberto, então, por favor, seja paciente enquanto aprendo a gerenciar este projeto adequadamente. Eu gerencio uma empresa de capital de risco durante o dia, então geralmente estarei verificando PRs e Issues à noite depois de colocar meus filhos para dormir - o que pode não ser todas as noites. Estou aberto à ideias de trazer apoio, atualizarei esta seção em breve (expectativas, visões, etc). Estou conversando com muitas pessoas e aprendendo - aguarde atualizações!
+
+# Histórico
+
+BabyAGI é uma versão simplificada do original [Agente Autônomo Orientado a Tarefas](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 de março de 2023) compartilhado no Twitter. Esta versão está reduzida a 140 linhas: 13 comentários, 22 espaços em branco e 105 de código. O nome do repositório surgiu na reação ao agente autônomo original - o autor não pretende insinuar que isso seja AGI.
+
+Feito com amor por [@yoheinakajima](https://twitter.com/yoheinakajima), que por acaso é um VC (adoraria ver o que você está construindo!)
\ No newline at end of file
diff --git a/docs/README-ro.md b/docs/README-ro.md
new file mode 100644
index 00000000..d9a446f0
--- /dev/null
+++ b/docs/README-ro.md
@@ -0,0 +1,78 @@
+
+ babyagi
+
+
+
+# Obiectiv
+Acest script Python este un exemplu de sistem de gestionare a sarcinilor alimentat de AI. Sistemul utilizează API-urile OpenAI și Pinecone pentru a crea, prioritiza și executa sarcini. Ideea principală din spatele acestui sistem este de a creea sarcini pe baza rezultatelor sarcinilor anterioare și a unui obiectiv predefinit. Apoi, scriptul utilizează capacitățile de procesare a limbajului natural (NLP) ale OpenAI pentru a crea sarcini noi pe baza obiectivului și a Pinecone pentru a stoca și recupera rezultatele sarcinilor pentru context. Aceasta este o versiune redusă a [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 martie 2023).
+
+Acest README va acoperi următoarele:
+
+* [Cum funcționează scriptul](#cum-functioneaza)
+
+* [Cum se utilizează scriptul](#cum-se-utilizeaza)
+
+* [Modele acceptate](#modele-acceptate)
+
+* [Avertisment despre rularea continuă a scriptului](#avertisment-rulare-continua)
+# Cum funcționează
+Scriptul funcționează prin executarea unei bucle infinite care face următorii pași:
+
+1. Extrage prima sarcină din lista de sarcini.
+2. Trimite sarcina la agentul de execuție, care utilizează API-ul OpenAI pentru a finaliza sarcina în funcție de context.
+3. Îmbogățește rezultatul și îl stochează în Pinecone.
+4. Creează noi sarcini și reprioritizează lista de sarcini în funcție de obiectiv și de rezultatul sarcinii anterioare.
+Funcția execution_agent() este locul unde se utilizează API-ul OpenAI. Aceasta primește doi parametri: obiectivul și sarcina. Apoi, trimite o solicitare către API-ul OpenAI, care returnează rezultatul sarcinii. Solicitarea constă dintr-o descriere a sarcinii sistemului AI, a obiectivul și a sarcina însași. Rezultatul este apoi returnat sub forma unui șir de caractere.
+
+Funcția task_creation_agent() este locul unde se utilizează API-ul OpenAI pentru a crea sarcini noi în funcție de obiectivul și rezultatul sarcinii anterioare. Funcția primește patru parametri: obiectivul, rezultatul sarcinii anterioare, descrierea sarcinii și lista de sarcini curentă. Apoi, trimite o solicitare către API-ul OpenAI, care returnează o listă de sarcini noi sub formă de șiruri de caractere. Funcția returnează apoi sarcinile noi sub forma unei liste de dicționare, unde fiecare dicționar conține numele sarcinii.
+
+Funcția prioritization_agent() este locul unde se utilizează API-ul OpenAI pentru a reprioritiza lista de sarcini. Funcția primește un singur parametru, ID-ul sarcinii curente. Aceasta trimite o solicitare către API-ul OpenAI, care returnează lista de sarcini reprioritizează sub forma unei liste de numere.
+
+În cele din urmă, scriptul utilizează Pinecone pentru a stoca și recupera rezultatele sarcinilor pentru context. Scriptul creează un index Pinecone bazat pe numele tabelului specificat în variabila YOUR_TABLE_NAME. Pinecone este apoi utilizat pentru a stoca rezultatele sarcinilor în index, împreună cu numele sarcinii și orice metadate suplimentare.
+
+# Cum se utilizează
+Pentru a utiliza acest script, trebuie să faceți următorii pași:
+
+1. Clonați repository-ul folosind comanda `git clone https://github.com/yoheinakajima/babyagi.git` și navigați în directorul clonat cu comanda `cd`.
+2. Instalați pachetele necesare: `pip install -r requirements.txt`
+3. Copiați fișierul .env.example în .env cu comanda `cp .env.example .env`. Acesta este locul unde veți seta variabilele următoare.
+4. Setați-vă cheile API OpenAI și Pinecone în variabilele OPENAI_API_KEY, OPENAPI_API_MODEL și PINECONE_API_KEY.
+5. Setați mediul Pinecone în variabila PINECONE_ENVIRONMENT.
+6. Setați numele tabelului, unde vor fi stocate rezultatele sarcinilor, în variabila TABLE_NAME.
+7. (Opțional) Setați obiectivul sistemului de gestionare a sarcinilor în variabila OBJECTIVE.
+8. (Opțional) Setați prima sarcină a sistemului în variabila INITIAL_TASK.
+9. Rulați scriptul.
+
+Toate valorile opționale de mai sus pot fi specificate și în linia de comandă.
+
+# Modele acceptate
+
+Acest script funcționează cu toate modelele OpenAI, precum și cu Llama prin intermediul Llama.cpp. Modelul implicit este **gpt-3.5-turbo**. Pentru a utiliza un alt model, specificați-l prin intermediul variabilei OPENAI_API_MODEL sau utilizați linia de comandă.
+
+## Llama
+
+Descărcați ultima versiune a [Llama.cpp](https://github.com/ggerganov/llama.cpp) și urmați instrucțiunile. De asemenea, veți avea nevoie si de ponderile (weights) modelului Llama.
+
+ - **Sub nicio formă să nu partajați IPFS, link-uri magnetice sau orice alte link-uri către descărcări de modele în niciun loc din acest repository, inclusiv în issues, discussions sau pull requests. Acestea vor fi șterse imediat.**
+
+După aceea, legați `llama/main` de llama.cpp/main și `models` de folderul în care aveți ponderile modelului Llama. Apoi rulați scriptul cu `OPENAI_API_MODEL=llama` sau cu argumentul `-l`.
+
+# Avertisment
+Acest script este conceput să fie rulat continuu ca parte a unui sistem de gestionare a sarcinilor. Rularea continuă a acestui script poate duce la utilizarea ridicată a API-ului, deci vă rugăm să-l utilizați responsabil. În plus, scriptul necesită ca API-urile OpenAI și Pinecone să fie configurate corect, deci asigurați-vă de asta înainte de a rula scriptul.
+
+# Contribuție
+
+Nu mai e nevoie sa spun că BabyAGI este încă în stadiul său incipient, și de aceea încă încercam să-i determinăm direcția și pașii necesari pentru a ajunge acolo. În prezent, un obiectiv de design cheie pentru BabyAGI este să fie *simplu*, astfel încât să fie ușor de înțeles și de dezvoltat pe el. Pentru a menține această simplitate, vă rugăm să respectați următoarele instrucțiuni atunci când trimiteți PR-uri:
+
+* Concentrați-vă pe modificări mici și modulare, în loc să refactorizați extensiv.
+* Când introduceți noi funcționalități, furnizați o descriere detaliată a cazului specific pe care îl abordați.
+
+Un mesaj de la @yoheinakajima (5 aprilie 2023):
+
+> Știu că există un număr crescut de PR-uri și vă apreciez răbdarea - sunt nou în GitHub/OpenSource și nu mi-am planificat disponibilitatea timpului corespunzător în această săptămână. Re: direcție: sunt în dubii dacă să păstrez BabyAGI simplu sau să-l extind - în prezent, sunt înclinat să mențin un nucleu de Baby AGI simplu și să-l folosesc ca platformă pentru a susține și promova diferite abordări de extindere a acestuia (de ex. BabyAGIxLangchain ca o direcție). Cred că există diverse abordări opinate care merită explorate și văd valoare în a avea un loc central pentru a le compara și discuta. Mai multe actualizări în curând.
+Sunt nou pe GitHub și în lumea open source, deci vă rog să fiți răbdători în timp ce învăț să gestionez acest proiect în mod corespunzător. În timpul zilei, conduc o firmă de capital de risc (VC), astfel încât în general voi verifica PR-urile și problemele noaptea, după ce îmi culc copiii - ceea ce s-ar putea să nu fie în fiecare noapte. Sunt deschis ideii de a aduce suport, voi actualiza această secțiune în curând (așteptări, viziuni, etc.). Vorbind cu mulți oameni și învățând - țineți aproape pentru actualizări!
+
+# Povestea din spate
+BabyAGI este o versiune simplificată a originalului [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 martie 2023), fiind distribuit pe Twitter. Această versiune este redusă la 140 de linii de cod: 13 comentarii, 22 blank-uri și 105 linii de cod efectiv. Numele repo-ului a apărut ca o reacție la agentul autonom original - autorul nu intenționează să sugereze că acesta este AGI.
+
+Realizat cu dragoste de [@yoheinakajima](https://twitter.com/yoheinakajima), care se întâmplă să fie un VC (ar fi încântat să vadă ce construiți!)
diff --git a/docs/README-ru.md b/docs/README-ru.md
new file mode 100644
index 00000000..65b2f64a
--- /dev/null
+++ b/docs/README-ru.md
@@ -0,0 +1,78 @@
+
+ babyagi
+
+
+
+# Задача
+Этот Python-скрипт является примером системы управления задачами на основе искусственного интеллекта. Система использует API OpenAI и Pinecone для создания, определения приоритетов и выполнения задач. Основная идея этой системы заключается в том, что она создает задачи на основе результатов предыдущих задач и заранее определенной цели. Затем скрипт использует возможности обработки естественного языка (NLP) OpenAI для создания новых задач на основе цели, а Pinecone - для хранения и извлечения результатов задач в контексте. Это урезанная версия оригинального [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023).
+
+В этом README будет описано следующее:
+
+* [Как работает скрипт](#как-это-работает)
+
+* [Как использовать скрипт](#как-этим-пользоваться)
+
+* [Поддерживаемые Модели](#поддерживаемые-модели)
+
+* [Предупреждение о непрерывном запуске скрипта](#предупреждение-о-запуске-скрипта)
+# Как это работает
+Скрипт работает путем запуска бесконечного цикла, который выполняет следующие действия:
+
+1. Вытаскивает первую задачу из списка задач.
+2. Отправляет задачу агенту выполнения, который использует API OpenAI для выполнения задачи на основе контекста.
+3. Обогащает результат и сохраняет его в Pinecone.
+4. Создает новые задачи и изменяет приоритеты в списке задач на основе цели и результата предыдущей задачи.
+
+Функция execution_agent() является тем местом, где используется API OpenAI. Она принимает два параметра: цель и задачу. Затем она посылает подсказку API OpenAI, который возвращает результат выполнения задачи. Подсказка состоит из описания задачи системы искусственного интеллекта, цели и самой задачи. Результат возвращается в виде строки.
+
+Функция task_creation_agent() - это функция, в которой API OpenAI используется для создания новых задач на основе цели и результата предыдущей задачи. Функция принимает четыре параметра: цель, результат предыдущей задачи, описание задачи и текущий список задач. Затем она отправляет запрос в API OpenAI, который возвращает список новых задач в виде строк. Затем функция возвращает новые задачи в виде списка словарей, где каждый словарь содержит название задачи.
+
+Функция prioritization_agent() - это функция, в которой API OpenAI используется для изменения приоритетов списка задач. Функция принимает один параметр - идентификатор текущей задачи. Она отправляет запрос в API OpenAI, который возвращает список задач с измененными приоритетами в виде нумерованного списка.
+
+Наконец, скрипт использует Pinecone для хранения и извлечения результатов задач в контексте. Скрипт создает индекс Pinecone на основе имени таблицы, указанной в переменной YOUR_TABLE_NAME. Затем Pinecone используется для хранения результатов задачи в индексе, вместе с именем задачи и любыми дополнительными метаданными.
+
+# Как этим пользоваться
+Чтобы воспользоваться скриптом, необходимо выполнить следующие шаги:
+
+1. Клонируйте репозиторий с помощью `git clone https://github.com/yoheinakajima/babyagi.git` и `cd` в клонированный репозиторий.
+2. Установите необходимые пакеты: `pip install -r requirements.txt`.
+3. Скопируйте файл .env.example в .env: `cp .env.example .env`. Здесь вы установите следующие переменные.
+4. Задайте ключи API OpenAI и Pinecone в переменных OPENAI_API_KEY, OPENAPI_API_MODEL и PINECONE_API_KEY.
+5. Установите окружение Pinecone в переменной PINECONE_ENVIRONMENT.
+6. Задайте имя таблицы, в которой будут храниться результаты задачи, в переменной TABLE_NAME.
+7. (Необязательно) Задайте цель системы управления задачами в переменной OBJECTIVE.
+8. (Необязательно) Задайте первую задачу системы в переменной INITIAL_TASK.
+9. Запустите скрипт.
+
+Все необязательные значения, указанные выше, могут быть также заданы в командной строке.
+
+# Поддерживаемые Модели
+
+Этот скрипт работает со всеми моделями OpenAI, а также с Llama через Llama.cpp. Модель по умолчанию - **gpt-3.5-turbo**. Чтобы использовать другую модель, укажите ее через OPENAI_API_MODEL или используйте командную строку.
+
+## Llama
+
+Скачайте последнюю версию [Llama.cpp](https://github.com/ggerganov/llama.cpp) и следуйте инструкциям для ее создания. Вам также понадобятся модельные грузы (model weights) Llama.
+- **Ни при каких обстоятельствах не делитесь IPFS, magnet-ссылками или любыми другими ссылками на загрузку моделей в этом репозитории, в том числе в вопросах, обсуждениях или запросах. Они будут немедленно удалены.**
+
+После этого соедините `llama/main` с llama.cpp/main и `models` с папкой, где у вас лежат веса моделей Llama. Затем запустите скрипт с аргументом `OPENAI_API_MODEL=llama` или `-l`.
+
+# Предупреждение
+Этот скрипт предназначен для непрерывного выполнения в рамках системы управления задачами. Постоянный запуск этого скрипта может привести к высокому использованию API поэтому, пожалуйста, используйте его ответственно. Кроме того, скрипт требует правильной настройки API OpenAI и Pinecone, поэтому убедитесь, что вы настроили API перед запуском скрипта.
+
+# Вклад в развитие проекта
+
+BabyAGI все еще находится в зачаточном состоянии, поэтому мы определяем его направление и шаги развития. В настоящее время основная цель дизайна BabyAGI - быть *простым*, чтобы его было легко понять и развивать. Чтобы сохранить эту простоту, мы просим вас придерживаться следующих правил при подаче PR:
+* Сосредоточьтесь на небольших модульных модификациях, а не на обширном рефакторинге.
+* При введении новых функций предоставляйте подробное описание конкретного случая использования, который вы рассматриваете.
+
+Заметка от @yoheinakajima (Apr 5th, 2023):
+
+> Я знаю, что количество PR растет, ценю ваше терпение - поскольку я новичок на GitHub/OpenSource и не планировал свое время на этой неделе. Что касается направления, я размышлял о сохранении простоты и расширении - сейчас я склоняюсь к сохранению простоты ядра Baby AGI и использованию его в качестве платформы для поддержки и продвижения различных подходов к его расширению (например, BabyAGIxLangchain как одно из направлений). Я считаю, что существуют различные подходы, которые стоит изучить, и я вижу ценность в наличии центрального места для сравнения и обсуждения. Больше обновлений будет в ближайшее время.
+
+Я новичок в GitHub и Open Source поэтому, пожалуйста, будьте терпеливы, пока я учусь правильно управлять этим проектом. Днем я работаю в венчурной фирме, так что обычно я буду проверять PR и проблемы по ночам, после того как уложу своих детей - что может происходить не каждый вечер. Открыт для идеи привлечения поддержки, скоро обновлю этот раздел (ожидания, видение проекта и т.д.). Общаюсь со многими людьми и учусь - следите за обновлениями!
+
+# Предистория
+BabyAGI - это сокращенная версия оригинального [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023), опубликованного в Twitter. Эта версия сократилась до 140 строк: 13 комментариев, 22 пробела и 105 кода. Название репозитория появилось в реакции на оригинальный автономный агент - автор не хочет сказать, что это AGI.
+
+Сделано с любовью [@yoheinakajima](https://twitter.com/yoheinakajima), который, как оказалось, является VC (хотел бы посмотреть, что вы создаете!).
\ No newline at end of file
diff --git a/docs/README-si.md b/docs/README-si.md
new file mode 100644
index 00000000..fcbae5f1
--- /dev/null
+++ b/docs/README-si.md
@@ -0,0 +1,85 @@
+
+ babyagi
+
+
+
+# Cilj
+
+Ta Python skripta je primer sistema za upravljanje opravil, ki ga poganja AI oz. umetna inteligenca (UI). Sistem uporablja OpenAI-jev API in Pinecone za ustvarjanje in določanje prioritet ter izvajanje nalog. Glavna ideja tega sistema je, da ustvarja naloge na podlagi rezultatov prejšnjih nalog in vnaprej določenega cilja. Skripta nato uporabi obdelavo naravnega jezika (NLP) ponudnika OpenAI za ustvarjanje novih nalog na podlagi cilja ter Pinecone za shranjevanje in pridobivanje rezultatov nalog za kontekst. To je poenostavljena različica izvirnega [avtonomnega agenta, ki temelji na opravilih](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28. marec 2023).
+
+Ta README zajema naslednje:
+
+- [Kako deluje skripta](#how-it-works)
+
+- [Kako uporabljati skripto](#how-to-use)
+
+- [Podprti modeli](#supported-models)
+
+– [Opozorilo o neprekinjenem izvajanju skripte](#continous-script-warning)
+
+# Kako deluje
+
+Skripta deluje tako, da izvaja neskončno zanko, ki izvaja naslednje korake:
+
+1. Izvleče prvo opravilo s seznama opravil.
+2. Pošlje nalogo izvršilnemu posredniku (agentu), ki uporablja API OpenAI za dokončanje naloge glede na kontekst.
+3. Obogati rezultat in ga shrani v Pinecone.
+4. Ustvari nove naloge in ponovno določi prednost seznama nalog glede na cilj in rezultat prejšnje naloge.
+ V funkciji execution_agent() se uporablja OpenAI API. Zajema dva parametra: cilj in nalogo. Nato pošlje poziv API-ju OpenAI, ki vrne rezultat naloge. Poziv je sestavljen iz opisa naloge sistema AI, cilja in same naloge. Rezultat je nato vrnjen kot niz.
+
+Funkcija task_creation_agent() je mesto, kjer se API OpenAI uporablja za ustvarjanje novih nalog na podlagi cilja in rezultata prejšnje naloge. Funkcija ima štiri parametre: cilj, rezultat prejšnje naloge, opis naloge in trenutni seznam nalog. Nato pošlje poziv API-ju OpenAI, ki vrne seznam novih nalog kot nize. Funkcija nato vrne nova opravila kot seznam slovarjev, kjer vsak slovar vsebuje ime opravila.
+
+Funkcija prioritization_agent() je mesto, kjer se API OpenAI uporablja za ponovno določanje prioritet seznama opravil. Funkcija sprejme en parameter, ID trenutne naloge. Pošlje poziv API-ju OpenAI, ki vrne ponovno prednostni seznam opravil kot oštevilčen seznam.
+
+Skripta uporablja Pinecone za shranjevanje in pridobivanje rezultatov nalog za kontekst. Skripta ustvari Pinecone indeks na podlagi imena tabele, določenega v spremenljivki YOUR_TABLE_NAME. Pinecone se nato uporabi za shranjevanje rezultatov opravila v indeksu, skupaj z imenom opravila in vsemi dodatnimi metapodatki.
+
+# Navodila za uporabo
+
+Za uporabo skripte sledite naslednjim korakom:
+
+1. Klonirajte repozitorij prek `git clone https://github.com/yoheinakajima/babyagi.git` in `cd` v klonirano repozitorij.
+2. Namestite zahtevane pakete: `pip install -r requirements.txt`
+3. Kopirajte datoteko .env.example v .env: `cp .env.example .env`. Tukaj nastavite naslednje spremenljivke.
+4. Nastavite API ključe za OpenAI in Pinecone v spremenljivkah OPENAI_API_KEY, OPENAPI_API_MODEL in PINECONE_API_KEY.
+5. Nastavite okolje Pinecone v spremenljivki PINECONE_ENVIRONMENT.
+6. V spremenljivki TABLE_NAME nastavite ime tabele, v katero bodo shranjeni rezultati naloge.
+7. (Izbirno) Nastavite cilj sistema za upravljanje opravil v spremenljivki OBJECTIVE.
+8. (Izbirno) Nastavite prvo nalogo sistema v spremenljivki INITIAL_TASK.
+9. Zaženite skripto.
+
+Vse izbirne vrednosti zgoraj lahko podate tudi v ukazni vrstici.
+
+# Podprti modeli
+
+Skripta deluje z vsemi modeli OpenAI, pa tudi z Llamo prek Llama.cpp. Privzeti model je **gpt-3.5-turbo**. Če želite uporabiti drug model, ga določite prek OPENAI_API_MODEL ali uporabite ukazno vrstico (CLI).
+
+## Llama
+
+Prenesite najnovejšo različico [Llama.cpp](https://github.com/ggerganov/llama.cpp) in sledite navodilom za namestitev. Potrebovali boste tudi uteži za model Llama.
+
+- **Pod nobenim pogojem ne delite IPFS, magnetnih povezav ali kakršnih koli drugih povezav do prenosov modelov kjer koli v tem repozitoriju, vključno z vprašanji, razpravami ali pull requesti. Objave bodo nemudoma izbrisane.**
+
+Po tem povežite `llama/main` na llama.cpp/main in `models` v mapo, kjer imate uteži modela Llama. Nato zaženite skripto z argumentom `OPENAI_API_MODEL=llama` ali `-l`.
+
+# Opozorilo
+
+Skripta je zasnovana tako, da se neprekinjeno izvaja kot del sistema za upravljanje opravil. Neprekinjeno izvajanje tega skripta lahko povzroči visoko uporabo API-ja, zato ga uporabljajte odgovorno. Poleg tega skripta zahteva, da sta API-ja OpenAI in Pinecone pravilno nastavljena, zato se prepričajte, da ste nastavili API-je preden zaženete skripto.
+
+# Prispevanje
+
+BabyAGI je še vedno v povojih, zato še vedno določamo njegovo smer in korake. Trenutno je ključni cilj oblikovanja za BabyAGI biti _preprost_, tako da ga je enostavno razumeti in graditi na njem. Da bi ohranili to preprostost, vas vljudno prosimo, da pri oddaji PR-jev upoštevate naslednje smernice:
+
+- Osredotočite se na majhne, modularne spremembe namesto na obsežno preoblikovanje.
+- Ko uvajate nove funkcije, navedite podroben opis specifičnega primera uporabe, ki ga obravnavate.
+
+Zapis od @yoheinakajima (5. april 2023):
+
+> I know there are a growing number of PRs, appreciate your patience - as I am both new to GitHub/OpenSource, and did not plan my time availability accordingly this week. Re:direction, I've been torn on keeping it simple vs expanding - currently leaning towards keeping a core Baby AGI simple, and using this as a platform to support and promote different approaches to expanding this (eg. BabyAGIxLangchain as one direction). I believe there are various opinionated approaches that are worth exploring, and I see value in having a central place to compare and discuss. More updates coming shortly.
+
+Sem (@yoheinkajima) nov uporabnik GitHub-a in odprtokodnih programov ter okolja, zato bodite potrpežljivi, da se naučim pravilno upravljati ta projekt. Podnevi vodim podjetje za tvegani kapital, zato bom ponoči, potem ko spravim svoje otroke, na splošno preverjal PR-je in težave – kar morda ne bo vsako noč. Odprt sem za idejo o zagotavljanju podpore, kmalu bom posodobil ta razdelek (pričakovanja, vizije itd.). Pogovarjam se z veliko ljudmi in se še učim – počakajte na novosti!
+
+# Backstory
+
+BabyAGI je poenostavljena različica izvirnega [avtonomnega agenta, ki temelji na opravilih](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28. marec 2023), ki je bil predstavljen na Twitterju. Ta različica ima 140 vrstic: 13 komentarjev, 22 presledkov in 105 kode. Ime repozitorija se je pojavilo kot odziv na prvotnega avtonomnega agenta - avtor ne želi namigovati, da je to AGI (splošna umetna inteligenca).
+
+Z ljubeznijo naredil [@yoheinakajima](https://twitter.com/yoheinakajima), ki je po naključju VC (rad bi videl, kaj gradite!)
diff --git a/docs/README-tr.md b/docs/README-tr.md
new file mode 100644
index 00000000..9efaf4ea
--- /dev/null
+++ b/docs/README-tr.md
@@ -0,0 +1,97 @@
+
+ babyagi
+
+
+
+# Diğer README çevirileri:
+[](docs/README-ar.md)
+[](docs/README-fr.md)
+[](docs/README-pl.md)
+[](docs/README-pt-br.md)
+[](docs/README-ro.md)
+[](docs/README-ru.md)
+[](docs/README-si.md)
+[](docs/README-es.md)
+[](docs/README-ua.md)
+[](docs/README-cn.md)
+[](docs/README-zh-tw.md)
+[](docs/README-ja.md)
+[](docs/README-ko.md)
+[](docs/README-hu.md)
+[](docs/README-fa.md)
+[](docs/README-de.md)
+[](docs/README-in.md)
+
+
+# Kullanım
+Bu Python scripti, LLM tabanlı task üretim ve yönetme sistemi odaklı bir çalışmadır. Sistem, istenen konu hakkında taskları oluşturmak, önceliklendirmek ve sorgulamak için OpenAI ve Pinecone API'lerini kullanır. Bu sistemin arkasındaki temel fikir, önceki görevlerin sonuçlarına ve önceden tanımlanmış bir hedefe dayalı görevler oluşturmasıdır. Komut dosyası daha sonra hedefe dayalı yeni görevler oluşturmak için OpenAI'nin doğal dil işleme (NLP) yeteneklerini ve bağlam için görev sonuçlarını depolamak ve almak için Pinecone'u kullanır. Bu çalışma, [BabyAGI-twitter.com](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 Mart 2023) paylaşımının basit bir kopyasıdır.
+
+Bu README aşağıdakileri kapsayacaktır:
+
+* [Nasıl çalışır](#nasil-calisir)
+
+* [Nasıl kullanılır](#nasil-kullanilir)
+
+* [Desteklenen Modeller](#desteklenen-modeller)
+
+* [Döngüsel çalıştırma ile ilgili uyarı](#uyari)
+
+# Nasıl Çalışır
+
+Script, aşağıdaki adımları gerçekleştiren sonsuz bir döngü çalıştırarak çalışır:
+
+1. Görev listesinden ilk görevi çeker.
+2. Görevi, ilk girdiye dayalı olarak görevi tamamlamak için OpenAI'nin API'sini kullanan yürütme aracısına gönderir.
+3. Sonucu zenginleştirir ve Pinecone'da saklar.
+4. Yeni görevler oluşturur ve önceki görevin amacına ve sonucuna göre görev listesini yeniden önceliklendirir.
+execution_agent() işlevi, OpenAI API'nin kullanıldığı yerdir. İki parametre alır: amaç ve görev. Ardından OpenAI'nin API'sine görevin sonucunu döndüren bir bilgi istemi gönderir. İstem, AI sisteminin görevinin, amacının ve görevin kendisinin bir açıklamasından oluşur. Sonuç daha sonra bir dizi olarak döndürülür.
+
+task_creation_agent() işlevi, önceki görevin amacına ve sonucuna dayalı olarak yeni görevler oluşturmak için OpenAI'nin API'sinin kullanıldığı yerdir. İşlev dört parametre alır: amaç, önceki görevin sonucu, görev açıklaması ve geçerli görev listesi. Ardından, OpenAI'nin API'sine yeni görevlerin bir listesini dizeler olarak döndüren bir bilgi istemi gönderir. İşlev daha sonra yeni görevleri, her bir sözlüğün görevin adını içerdiği bir sözlük listesi olarak döndürür.
+
+Prioritization_agent() işlevi, görev listesini yeniden önceliklendirmek için OpenAI'nin API'sinin kullanıldığı yerdir. İşlev, geçerli görevin kimliği olan bir parametre alır. OpenAI'nin API'sine, yeniden önceliklendirilen görev listesini numaralı bir liste olarak döndüren bir bilgi istemi gönderir.
+
+Son olarak, betik, bağlam için görev sonuçlarını depolamak ve almak için Pinecone'u kullanır. Komut dosyası, YOUR_TABLE_NAME değişkeninde belirtilen tablo adını temel alan bir Çam Kozası dizini oluşturur. Çam kozası daha sonra görevin sonuçlarını, görev adı ve herhangi bir ek meta veri ile birlikte dizinde depolamak için kullanılır.
+
+# Nasıl Kullanılır
+Scripti kullanmak için şu adımları izlemeniz gerekir:
+
+1. `git clone https://github.com/yoheinakajima/babyagi.git` ve `cd` aracılığıyla repoyu lokal bilgisayarınıza kopyalayın.
+2. Gerekli paketleri kurun: `pip install -r requirements.txt`
+3. .env.example dosyasını .env'ye kopyalayın: `cp .env.example .env`. Aşağıdaki değişkenleri ayarlayacağınız yer burasıdır.
+4. OpenAI ve Pinecone API anahtarlarınızı OPENAI_API_KEY, OPENAPI_API_MODEL ve PINECONE_API_KEY değişkenlerinde ayarlayın.
+5. PINECONE_ENVIRONMENT değişkeninde Pinecone ortamını ayarlayın.
+6. TABLE_NAME değişkeninde görev sonuçlarının saklanacağı tablonun adını belirleyin.
+7. (İsteğe bağlı) OBJECTIVE değişkeninde görev yönetimi sisteminin hedefini belirleyin.
+8. (İsteğe bağlı) INITIAL_TASK değişkeninde sistemin ilk görevini ayarlayın.
+9. Scripti çalıştırın.
+
+# Desteklenen Modeller
+
+Bu script, tüm OpenAI modellerinin yanı sıra Llama.cpp aracılığıyla Llama modelleri ile de çalışmaktadır. Varsayılan olarak temelde çalışan model **gpt-3.5-turbo**'dur. Farklı bir model kullanmak için OPENAI_API_MODEL üzerinden model ismini belirtmeniz gerekmektedir.
+
+## Lama kullanmak için
+
+[Llama.cpp](https://github.com/ggerganov/llama.cpp) dosyasının en son sürümünü indirin ve oluşturmak için talimatları izleyiniz. Ek olarak, Llama model-weights dosyasına da ihtiyacınız olacaktır.
+
+ - **Issues, discussions veya pull requests gibi bu reponun herhangi bir yerinde IPFS paylaşımı, magnet linkleri, yada diğer tüm model indirme bağlantılarını hiçbir şekilde paylaşmayınız. Hızlı bir şekilde silineceklerdir.**
+
+Daha sonra `llama/main`i llama.cpp/main'e ve `models`i Lama model ağırlıklarının olduğu klasöre bağlayın. Ardından scripti `OPENAI_API_MODEL=llama` veya `-l` argümanı ile çalıştırın.
+
+# Uyarı
+Bu komut dosyası, bir görev yönetim sisteminin parçası olarak sürekli olarak (for loop mantığı ile) çalıştırılmak üzere tasarlanmıştır. Bu komut dosyasının sürekli olarak çalıştırılması yüksek sayıda API request isteği kullanımına neden olabilir, bu nedenle lütfen kullanım sürenize dikkat ediniz. Ayrıca script, OpenAI ve Pinecone API'lerinin doğru şekilde kurulmasını gerektirir, bu nedenle betiği çalıştırmadan önce API'leri sırasıyla ve düzgün şekilde kurduğunuzdan emin olmanız tavsiye edilmektedir.
+
+# Katkılarınız
+BabyAGI henüz emekleme aşamasında olan bir çalışmadır ve bu nedenle hala ileri adımların belirlenmesine ihtiyaç duymaktadır. Şu anda, BabyAGI için en önemli hedefimiz, anlaşılması ve üzerine geliştirilmesi konusunda *basit* olmaktır. Bu sadeliği korumak için, PR'ları gönderirken aşağıdaki yönergelere uymanızı rica ederiz:
+* Kapsamlı yeniden düzenleme yerine küçük, modüler değişikliklere odaklanın.
+* Yeni özellikler eklerken, kullanım durumunu ayrıntılı bir açıklamasını sağlayın.
+
+Ana geliştiricinin Twitter'dan paylaştığı güncelleme @yoheinakajima (Apr 5th, 2023):
+
+> I know there are a growing number of PRs, appreciate your patience - as I am both new to GitHub/OpenSource, and did not plan my time availability accordingly this week. Re:direction, I've been torn on keeping it simple vs expanding - currently leaning towards keeping a core Baby AGI simple, and using this as a platform to support and promote different approaches to expanding this (eg. BabyAGIxLangchain as one direction). I believe there are various opinionated approaches that are worth exploring, and I see value in having a central place to compare and discuss. More updates coming shortly.
+
+I am new to GitHub and open source, so please be patient as I learn to manage this project properly. I run a VC firm by day, so I will generally be checking PRs and issues at night after I get my kids down - which may not be every night. Open to the idea of bringing in support, will be updating this section soon (expectations, visions, etc). Talking to lots of people and learning - hang tight for updates!
+
+# İlk zamanlar
+BabyAGI, Twitter'da paylaşılan [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20)'nin (28 Mart 2023) sadeleştirilmiş bir sürümüdür. Reponun adı, orijinal otonom aracıya tepki olarak ortaya çıkmıştır ve ana geliştiricimiz, bunun bir AGI olduğunu tam anlamıyla iddia etmemektedir.
+
+Bir VC olan [@yoheinakajima](https://twitter.com/yoheinakajima) tarafından sevgiyle yapılmıştır (ne inşa ettiğinizi görmek ister!)
diff --git a/docs/README-ua.md b/docs/README-ua.md
new file mode 100644
index 00000000..ac5532e8
--- /dev/null
+++ b/docs/README-ua.md
@@ -0,0 +1,79 @@
+
+ babyagi
+
+
+
+
+# Мета
+Цей Python-скрипт є прикладом системи управління задачами на основі штучного інтелекту. Система використовує API OpenAI та Pinecone для створення, пріоритезації та виконання задач. Основна ідея цієї системи полягає в тому, що вона створює задачі на основі результату попередніх задач та попередньо визначеної мети. Після цього скрипт використовує можливості обробки природньої мови (NLP) OpenAI для створення нових задач на основі мети та Pinecone для збереження та отримання результатів задач для контексту. Це спрощена версія оригінального [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 березня 2023 року).
+
+This README will cover the following:
+
+* [Як працює скрипт](#how-it-works)
+
+* [Як використовувати скрипт](#how-to-use)
+
+* [Підтримувані моделі](#supported-models)
+
+* [Попередження про постійну роботу скрипту](#continous-script-warning)
+# Як це працює
+Скрипт працює за допомогою безкінечного циклу, який виконує наступні кроки:
+
+1. Витягує першу задачу зі списку задач.
+2. Надсилає задачу до виконавчого агента, який використовує API OpenAI для виконання задачі на основі контексту.
+3. Збагачує результат та зберігає його в Pinecone.
+4. Створює нові задачі та змінює пріоритети списку задач на основі мети та результату попередньої задачі.
+Функція execution_agent() є місцем, де використовується API OpenAI. Вона приймає два параметри: мету та задачу. Далі вона відправляє запит до API OpenAI, який повертає результат задачі. Запит складається з опису задачі системи штучного інтелекту, мети та самої задачі. Результат повертається у вигляді строки(string).
+
+Функція task_creation_agent() - це місце, де використовується API OpenAI для створення нових завдань на основі цілей та результатів попереднього завдання. Функція приймає чотири параметри: мету, результат попереднього завдання, опис завдання та поточний список завдань. Після цього вона надсилає запит до API OpenAI, який повертає список нових завдань у вигляді строк(strings). Функція повертає нові завдання у вигляді списку словників(dictionary), де кожен словник містить назву завдання.
+
+Функція prioritization_agent() - це місце, де використовується API OpenAI для перепріоритизації списку завдань. Функція приймає один параметр - ID поточного завдання. Вона надсилає запит до API OpenAI, який повертає перепріоритизований список завдань у вигляді нумерованого списку.
+
+Наостанку, скрипт використовує Pinecone для зберігання та отримання результатів завдань для контексту. Скрипт створює індекс Pinecone на основі імені таблиці, яке вказано у змінній YOUR_TABLE_NAME. Pinecone використовується для зберігання результатів завдання в індексі, разом з назвою завдання та будь-якою додатковою метаданою.
+
+# Як використовувати скрипт
+Для використання скрипту вам потрібно виконати наступні кроки:
+
+1. Зклонуйте репозиторій через `git clone https://github.com/yoheinakajima/babyagi.git` та перейдіть до клонованого репозиторію за допомогою команди `cd`.
+2. Встановіть необхідні пакети: `pip install -r requirements.txt`
+3. Скопіюйте файл .env.example в .env: `cp .env.example .env`. Тут треба встановити наступні змінні.
+4. Встановіть свої ключі OpenAI та Pinecone API в змінні OPENAI_API_KEY, OPENAPI_API_MODEL та PINECONE_API_KEY.
+5. Встановіть середовище Pinecone у змінну PINECONE_ENVIRONMENT.
+6. Встановіть ім'я таблиці, де будуть зберігатись результати задач, у змінну TABLE_NAME.
+7. (Опціонально) Встановіть мету системи управління завданнями в змінну OBJECTIVE.
+8. (Опціонально) Встановіть перше завдання системи у змінну INITIAL_TASK.
+9. Запустіть скрипт.
+
+Всі необов'язкові значення вище також можна вказати через командний рядок.
+
+# Підтримувані моделі
+
+Цей скрипт працює з усіма моделями OpenAI, а також Llama через Llama.cpp. Модель за замовчуванням - **gpt-3.5-turbo**. Щоб використовувати іншу модель, вкажіть її через OPENAI_API_MODEL або використайте командний рядок.
+
+
+## Llama
+
+Завантажте останню версію [Llama.cpp](https://github.com/ggerganov/llama.cpp) та дотримуйтеся інструкцій для його компіляції. Вам також знадобляться вагові коефіцієнти моделі Llama.
+
+ - **Ні за яких обставин не діліться IPFS, magnet-посиланнями або будь-якими іншими посиланнями на завантаження моделі ніде в цьому репозиторії, включаючи issues, discussions або pull requests. Вони будуть негайно видалені.**
+
+Після цього прив'яжіть `llama/main` до `llama.cpp/main` та `models` до папки, де ви маєте вагові коефіцієнти моделі Llama. Потім запустіть скрипт з аргументом `OPENAI_API_MODEL=llama` або `-l`.
+
+# Попередження
+Цей скрипт призначений для постійної роботи в рамках системи управління завданнями. Постійний запуск цього скрипту може призвести до високого використання API, тому використовуйте його з обережністю. Крім того, для правильної роботи скрипту необхідно налаштувати API OpenAI та Pinecone, тому переконайтеся, що ви налаштували API перед запуском скрипту.
+
+# Контрибуція
+Звичайно, BabyAGI ще на початковому етапі, тому ми все ще визначаємо його напрямок та кроки для досягнення цілей. На даний момент ключовою ціллю дизайну BabyAGI є те, щоб він був *простим*, щоб його було легко зрозуміти та розширювати. Щоб зберегти цю простоту, ми люб'язно просимо дотримуватися наступних принципів надсилаючи PR:
+* Фокусуйтеся на невеликих, модульних змінах, а не на обширних рефакторингах.
+* При введенні нових функцій(features) надавайте детальний опис конкретного випадку використання(use case), який ви розглядаєте.
+
+Примітка від @yoheinakajima (5 квітня 2023 року):
+
+> Я знаю, що кількість запитів на злиття зростає, і дякую вам за терпіння - я ще новачок у GitHub/OpenSource, і не вдалося правильно розпланувати свій час на цей тиждень. Щодо напрямку, я роздираюся між збереженням простоти та розширенням - на даний момент нахил полягає на збереженні основної простої Baby AGI та використанні її як платформи для підтримки та просування різних підходів до розширення (наприклад, BabyAGIxLangchain як один з напрямків). Я вважаю, що є різні підходи, які варто досліджувати, і бачу цінність в тому, щоб мати центральне місце для порівняння та обговорення. Незабаром очікуються більш докладні оновлення.
+
+Я новачок на GitHub і у відкритому програмному забезпеченні, тому будь ласка, будьте терплячими, поки я вивчу правильне управління цим проектом. Я працюю в венчурній фірмі вдень, тому, як правило, перевірятиму PR та проблеми ввечері після того, як я вкладу спати своїх дітей - що може не бути кожної ночі. Готовий до ідеї залучення підтримки, скоро оновлю цей розділ (очікування, бачення і т.д.). Говорю з багатьма людьми та навчаюся - чекайте оновлень!
+
+# Передісторія
+BabyAGI - це спрощена версія оригінального [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (28 березня 2023 року) опублікованого на Twitter. Ця версія містить 140 рядків: 13 коментарів, 22 порожніх та 105 коду. Назва репозиторію виникла в реакції на оригінальний автономний агент - автор не має на меті натякати на AGI.
+
+Створено з любов'ю [@yoheinakajima](https://twitter.com/yoheinakajima), який виявилось є VC (було б цікаво побачити, що ви будуєте!)
diff --git a/docs/README-zh-tw.md b/docs/README-zh-tw.md
new file mode 100644
index 00000000..6c80ece4
--- /dev/null
+++ b/docs/README-zh-tw.md
@@ -0,0 +1,101 @@
+
+ babyagi
+
+
+
+# Readme 翻譯
+
+[](docs/README-pt-br.md)
+[](docs/README-ru.md)
+[](docs/README-si.md)
+[](docs/README-tr.md)
+[](docs/README-ua.md)
+[](docs/README-zh-tw.md)
+
+# 目標
+
+這個 Python 腳本是一個 AI 驅動的任務管理系統的範例。系統使用 OpenAI 和 Pinecone API 來創建、優先排序和執行任務。這個系統的主要概念是根據先前任務的結果和預定義的目標創建任務。腳本接著使用 OpenAI 的自然語言處理（NLP）能力根據目標創建新任務，並使用 Pinecone 存儲和檢索任務結果以獲取上下文。這是原始 [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20)（2023 年 3 月 28 日）的簡化版本。
+
+- [腳本如何運作](#工作原理)
+- [如何使用腳本](#如何使用)
+- [支持的模型](#支持的模型)
+- [連續運行腳本的警告](#警告)
+
+此 README 將涵蓋以下內容：
+
+# 工作原理
+
+腳本通過運行一個無限循環來執行以下步驟：
+
+從任務列表中提取第一個任務。
+將任務發送到執行代理，該代理使用 OpenAI 的 API 根據上下文完成任務。
+豐富結果並將其存儲在 Pinecone 中。
+根據目標和先前任務的結果創建新任務並重新排序任務列表。
+
+`execution_agent()` 函數是使用 OpenAI API 的地方。它需要兩個參數：
+
+1. 目標 (objective)
+2. 任務 (task)。
+
+然後將提示發送到 OpenAI 的 API，該 API 返回任務的結果。提示包括 AI 系統任務的描述、目標和任務本身。然後將結果作為 string (字串) 返回。
+
+`task_creation_agent()` 函數是使用 OpenAI 的 API 根據目標和先前任務的結果創建新任務的地方。該函數需要四個參數：
+
+1. 目標 (objective)
+2. 先前任務的結果 (result of the previous task)
+3. 任務描述 (task description)
+4. 當前任務列表 (current task list)
+
+然後將提示發送到 OpenAI 的 API，該 API 返回一個新任務的 string 列表。然後將新任務作為一個 list of dictionaries (字典列表) 返回，其中每個字典包含任務的名稱。
+
+`prioritization_agent()` 函數是使用 OpenAI 的 API 重新排序任務列表的地方。該函數需要一個參數，即當前任務的 ID。它將提示發送到 OpenAI 的 API，該 API 以編號列表的形式返回重新排序的任務列表。
+
+最後，腳本使用 Pinecone 存儲和檢索任務結果以獲取上下文。腳本根據 `YOUR_TABLE_NAME` 變數中指定的表名創建一個 Pinecone 索引。然後使用 Pinecone 將任務的結果存儲在索引中，以及任務名稱和任何其他元數據。
+
+# 如何使用
+
+要使用腳本，您需要執行以下步驟：
+
+1. 通過 `git clone https://github.com/yoheinakajima/babyagi.git` 複製存儲庫並 cd 進入複製的存儲庫。
+2. 安裝所需的軟件包：`pip install -r requirements.txt`
+3. 將 `.env.example` 文件複製到 `.env`：`cp .env.example .env`。這是您將設置以下變數的地方。
+4. 在 `OPENAI_API_KEY`, `OPENAPI_API_MODEL` 和 `PINECONE_API_KEY` 變數中設置您的 OpenAI 和 Pinecone API 密鑰。
+5. 在 `PINECONE_ENVIRONMENT` 變數中設置 Pinecone 環境。
+6. 在 `TABLE_NAME` 變數中設置將存儲任務結果的表名。
+7. （可選）在 `OBJECTIVE` 變數中設置任務管理系統的目標。
+8. （可選）在 `INITIAL_TASK` 變數中設置系統的第一個任務。
+9. 運行腳本。
+上述所有可選值也可以在命令行上指定。
+
+# 支持的模型
+
+此腳本適用於所有 OpenAI 模型，以及通過 [Llama.cpp](https://github.com/ggerganov/llama.cpp) 的 Llama。默認模型是 `gpt-3.5-turbo`。要使用其他模型，通過 `OPENAI_API_MODEL` 指定，或使用命令行。
+
+下載 Llama.cpp 的最新版本並按照說明進行製作。您還需要 Llama 模型權重。
+
+- **在任何情況下都不要在此存儲庫中的任何地方共享 IPFS、磁力鏈接 (magnet links) 或模型下載的任何其他鏈接，包括在問題、討論或拉取請求 (PR) 中。它們將立即被刪除。**
+
+之後將 `llama/main` 鏈接到 `llama.cpp/main`，將 `models` 鏈接到您擁有 Llama 模型權重的文件夾。然後使用 `OPENAI_API_MODEL=llama` 或 `-l` 參數運行腳本。
+
+# 警告
+
+此腳本旨在作為任務管理系統的一部分連續運行。連續運行此腳本可能導致高 API 使用率，因此請負起使用責任。此外，腳本要求正確設置 OpenAI 和 Pinecone API，因此在運行腳本之前請確保已設置 API。
+
+# 貢獻
+
+不用說，BabyAGI 仍處於起步階段，因此我們仍在確定其方向和實現的步驟。目前，對於 BabyAGI 的一個關鍵設計目標是保持 _簡單_，以便易於理解和構建。為了保持這種簡單性，當提交 PR 時，請遵循以下準則：
+
+- 專注於小型、模塊化的修改，而不是大規模重構。
+- 在引入新功能時，提供有關您正在解決的特定使用案例 (use case) 的詳細描述。
+
+@yoheinakajima（2023 年 4 月 5 日）的一條說明：
+
+> 我知道越來越多的 PR，感謝您的耐心 - 因為我既是 GitHub/OpenSource 的新手，又沒有妥善安排本周的時間。關於方向，我一直在簡單與擴展之間猶豫不決 - 目前傾向於保持核心 Baby AGI 簡單，並使用這個平台來支持和推廣擴展的不同方法（例如 BabyAGIxLangchain 作為一個方向）。我認為有各種有意義的方法值得探索，我認為在一個中心地方進行比較和討論具有價值。即將有更多更新。
+
+我是 GitHub 和開源的新手，所以在我學會如何正確管理這個項目時，請耐心等待。我白天經營一家創投公司，所以晚上在孩子們入睡後我通常會檢查 PR 和問題，這可能不是每天晚上。我們正在考慮引入支持，將很快更新這部分（期望、願景等）。我正在與很多人交流並學習，請耐心等待更新！
+
+# 背景故事
+
+BabyAGI 是原始 [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20)（2023 年 3 月 28 日）在 Twitter 上分享的精簡版本。這個版本縮減到了 140 行：13 條註釋、22 個空白和 105 個代碼。存儲庫的名字出現在對原始自主代理的反應中 - 作者並不意味著這是 AGI。
+
+由 [@yoheinakajima](https://twitter.com/yoheinakajima) 製作，他碰巧是一位創投者（很想看到您在打造什麼！）
diff --git a/docs/baby-agi-fig-ar.png b/docs/baby-agi-fig-ar.png
new file mode 100644
index 00000000..8735c429
Binary files /dev/null and b/docs/baby-agi-fig-ar.png differ
diff --git a/docs/babyagi.png b/docs/babyagi.png
new file mode 100644
index 00000000..602302e3
Binary files /dev/null and b/docs/babyagi.png differ
diff --git a/docs/inspired-projects.md b/docs/inspired-projects.md
new file mode 100644
index 00000000..16495946
--- /dev/null
+++ b/docs/inspired-projects.md
@@ -0,0 +1,113 @@
+# Inspired Projects
+
+This document highlights a curated selection of remarkable projects inspired by or built upon the concepts and ideas of BabyAGI. Our aim is to showcase the diversity and creativity of the community, foster collaboration, and provide inspiration for future projects. By exploring these examples, we hope you will gain valuable insights and ideas to enhance your own work.
+
+## Projects List
+
+1. [BabyAGI on Slack](https://twitter.com/frankc/status/1645898312594382848)
+ - Description: An implementation of BabyAGI in Slack! Each thread represents a new objective.
+ - Author: [Frank Chen](https://frankc.net)
+ - Twitter: https://twitter.com/frankc
+1. [AgentGPT](https://github.com/reworkd/AgentGPT)
+ - Description: Assemble, configure, and deploy autonomous AI Agents in your browser.
+ - Author: [Asim Shrestha](https://github.com/asim-shrestha)
+ - Twitter: https://twitter.com/asimdotshrestha
+1. [AgentLLM](https://github.com/idosal/AgentLLM)
+ - Description: AgentGPT that uses a browser-native LLM instead of ChatGPT.
+ - Author: [Ido Salomon](https://github.com/idosal)
+ - Twitter: https://twitter.com/idosal1
+1. [BabyAGI-asi](https://github.com/oliveirabruno01/babyagi-asi)
+ - Description: A modification that runs arbitrary python code to perform tasks - It manages to create routines for pyautogui, webscrapping, manages to execute actions on the computer and even controls its own memory
+ - Author: [Bruno De Oliveira](https://github.com/oliveirabruno01)
+ - Twitter: https://twitter.com/LatentLich
+1. [ai-legion](https://github.com/eumemic/ai-legion)
+ - Description: Similar in spirit to AutoGPT and Baby AGI, but written in the superior language that is TypeScript (Author's Description).
+ - Author: [eumemic](https://github.com/eumemic)
+ - Twitter: https://twitter.com/dysmemic
+1. [yourgoal](https://github.com/pj4533/yourgoal)
+ - Description: Swift implementation of BabyAGI.
+ - Author: [PJ Gray](https://github.com/pj4533)
+ - Twitter: https://twitter.com/pj4533
+1. [BabyAGIChatGPT](https://replit.com/@Skirano/BabyAGIChatGPT?v=1)
+ - Description: Plug-in to run autonomous agents directly within ChatGPT
+ - Author: [Pietro Schirano](https://replit.com/@Skirano)
+ - Twitter: https://twitter.com/skirano
+1. [Cognosys](https://www.cognosys.ai/)
+ - Description: web based version of AutoGPT/babyAGI
+ - Author: [Sully Omarr](https://github.com/sullyo)
+ - Twitter: https://twitter.com/SullyOmarr
+1. [Godmode](https://godmode.space/)
+ - Description: web based version of AutoGPT/babyAGI
+ - Authors: [Lonis](https://twitter.com/_Lonis_), [Emil Ahlbäck](https://github.com/FOLLGAD), and [fant](https://twitter.com/da_fant)
+ - Twitter: https://twitter.com/SullyOmarr
+1. [alphakit](https://alphakit.ai/)
+ - Description: A team of autonomous AI agents for everyone
+ - Author: [Andrew Yu](https://github.com/andrewyu0)
+ - Twitter: https://twitter.com/andrewcyu
+1. [Xircuits](https://github.com/XpressAI/xai-gpt-agent-toolkit)
+ - Description: This toolkit provides a comprehensive set of Xircuits components that allow you to experiment with and create Collaborative Large Language Model-based automatons (Agents) in the style of BabyAGI and Auto-GPT. By default, the toolkit comes with BabyAGI agents, but it is designed to be easily customizable with your own prompts.
+ - Author: [Eduardo Gonzalez](https://github.com/wmeddie)
+ - Twitter: https://twitter.com/wm_eddie
+1. [babyagijs](https://github.com/ericciarla/babyagijs)
+ - Description: BabyAGI for Javascript.
+ - Author: [Eric Ciarla](https://github.com/ericciarla)
+ - Twitter: https://twitter.com/ericciarla
+1. [Teenage-AGI](https://github.com/seanpixel/Teenage-AGI)
+ - Description: Inspired by the several Auto-GPT related Projects (predominently BabyAGI) and the Paper "Generative Agents: Interactive Simulacra of Human Behavior", this python project uses OpenAI and Pinecone to Give memory to an AI agent and also allows it to "think" before making an action (outputting text). Also, just by shutting down the AI, it doesn't forget its memories since it lives on Pinecone and its memory_counter saves the index that its on.
+ - Author: [Sean Pixel](https://github.com/seanpixel)
+ - Twitter: https://twitter.com/sean_pixel
+1. [babyagi-perl](https://github.com/nferraz/babyagi-perl)
+ - Description: BabyAGI for Perl.
+ - Author: [Nelson Ferraz](https://github.com/nelson-ferraz)
+1. [gptagent.js](https://github.com/lgrammel/gptagent.js)
+ - Description: A composable and extensible framework for creating AI agents with TypeScript/JavaScript.
+ - Author: [Lars Grammel](https://github.com/lgrammel)
+ - Twitter: https://twitter.com/lgrammel
+1. [babyagi-streamlit](https://github.com/dory111111/babyagi-streamlit)
+ - Description: Streamlit web app to make it more accessible.
+ - Author: [Dory](https://github.com/dory111111)
+ - Twitter: https://twitter.com/dory111111
+1. [Do Anything Machine](https://www.doanythingmachine.com/)
+ - Description: The Do Anything Machine helps you keep track of your tasks, prioritize them, and allows you to deploy AI agents to get your work done for you.
+ - Author: Garrett Scott
+ - Twitter: https://twitter.com/thegarrettscott
+1. [Babyagi-as-a-service](https://github.com/jina-ai/langchain-serve#-babyagi-as-a-service)
+ - Description: Integrate babyagi with your own applications - thanks to langchain-serve with one simple command - 𝐥𝐜-𝐬𝐞𝐫𝐯𝐞 𝐝𝐞𝐩𝐥𝐨𝐲 𝐛𝐚𝐛𝐲𝐚𝐠𝐢
+ - Author: [Deepankar Mahapatro](https://github.com/deepankarm)
+ - Twitter: https://twitter.com/_deepankarm_
+1. [gptrpg](https://github.com/dzoba/gptrpg)
+ - Description: A simple RPG-like environment for an LLM-enabled AI Agent to exist in
+ - Author: [Chris Dzoba](https://github.com/dzoba)
+ - Twitter: https://twitter.com/ChrisDzoba_
+1. [BabyAGI-ts](https://github.com/context-labs/babyagi-ts)
+ - Description: Port BabyAGI from Python to TypeScript and provide a friendly CLI tool that can be installed as a global NPM module
+ - Author: [Sam Hogan](https://github.com/samheutmaker)
+ - Twitter: https://twitter.com/0xSamHogan
+1. [LLMitlessAPI](https://github.com/adamcohenhillel/LLMitlessAPI)
+ - Description: API with one endpoint that does everything.
+ - Author: [Adam Cohen Hillel](https://github.com/adamcohenhillel)
+ - Twitter: https://twitter.com/adamcohenhillel
+1. [PuttyGPT](https://github.com/webgrip/PuttyGPT)
+ - Description: Wiring all this good stuff together. Weaviate, langchain, the ideas I see popping up everywhere, new concepts AI thinks off. Agents deploying other agents, concurrent requests, continuously training new finetuned models on data that's being gathered from its activities. It's FAR from a working prototype, but 100% worth a look.
+ - Author: [Ryan William Grippeling](https://github.com/ryangr0)
+ - Twitter: https://twitter.com/ryangrippeling
+1. [Chippr-AGI](https://github.com/chippr-robotics/chippr-agi)
+ - Description: Chippr-AGI is an open-source framework that uses AI models to automate task creation and prioritization. NodeJS, Redis, OpenAI/LLAMA
+ - Author: [Cody Burns](https://github.com/realcodywburns)
+ - Twitter: https://twitter.com/DontPanicBurns
+1. [Agent-LLM](https://github.com/Josh-XT/Agent-LLM)
+
+ - Description: Agent-LLM is a dynamic AI task management assistant with adaptive memory, web browsing, code evaluation, and a versatile plugin system for seamless integration with various AI providers and models both locally and remotely hosted.
+
+ - Author: [Josh XT](https://github.com/Josh-XT)
+
+ - Twitter: https://twitter.com/Josh_XT
+1. [sharpagi](https://github.com/sathyarajv/sharpagi)
+ - Description: C# dotnet implementation of BabyAGI.
+ - Author: [Sathyaraj Vadivel](https://github.com/sathyarajv)
+ - Twitter: https://twitter.com/sathyarajv
+1. [twitter-agent🐣](https://github.com/bigsky77/twitter-agent)
+ - Description: Twitter-Agent is an autonomous AI-powered agent for interacting directly with the Twitter API.
+ - Author: [BigSky](https://github.com/bigsky77)
+ - Twitter: https://twitter.com/bigsky_7
+
diff --git a/docs/weaviate.md b/docs/weaviate.md
new file mode 100644
index 00000000..82497a32
--- /dev/null
+++ b/docs/weaviate.md
@@ -0,0 +1,22 @@
+# How to setup
+
+## Setup
+
+1. Install weaviate client:
+
+```bash
+pip -r extensions/requirements.txt
+```
+
+2. Configure the following environment variables:
+
+```bash
+TABLE_NAME=BabyAGITableInWeaviate
+
+# Weaviate config
+# Uncomment and fill these to switch from local ChromaDB to Weaviate
+WEAVIATE_USE_EMBEDDED=true
+WEAVIATE_URL=
+WEAVIATE_API_KEY=
+```
+Follow step 4 onwards in main README
diff --git a/examples/custom_flask_example.py b/examples/custom_flask_example.py
deleted file mode 100644
index 865f4b06..00000000
--- a/examples/custom_flask_example.py
+++ /dev/null
@@ -1,23 +0,0 @@
-#this is an example of how to use the babyagi framework in a custom flask app
-
-from flask import Flask
-import babyagi
-from babyagi import register_function, load_functions
-
-app = Flask(__name__)
-
-# Use the babyagi blueprints
-babyagi.use_blueprints(app, dashboard_route='/dashboard')
-
-@register_function()
-def integrated_function():
- return "Hello from integrated function!"
-
-load_functions('plugins/firecrawl')
-
-@app.route('/')
-def home():
- return "Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app.run(host='0.0.0.0', port=8080)
diff --git a/examples/custom_route_example.py b/examples/custom_route_example.py
deleted file mode 100644
index 593cbb95..00000000
--- a/examples/custom_route_example.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# this is an example of how to use babyagi with custom routes
-
-from babyagi import create_app, register_function
-
-app = create_app('/dashboard')
-
-@register_function()
-def another_custom_function():
- return "Hello from another custom function!"
-
-@app.route('/')
-def home():
- return f"Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app.run(host='0.0.0.0', port=8080)
diff --git a/examples/quickstart_example.py b/examples/quickstart_example.py
deleted file mode 100644
index d7fddb4b..00000000
--- a/examples/quickstart_example.py
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-import babyagi
-import os
-
-
-app = babyagi.create_app('/dashboard')
-
-# Add OpenAI key to enable automated descriptions and embedding of functions.
-babyagi.add_key_wrapper('openai_api_key',os.environ['OPENAI_API_KEY'])
-
-
-@app.route('/')
-def home():
- return f"Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app.run(host='0.0.0.0', port=8080)
diff --git a/examples/self_build_example.py b/examples/self_build_example.py
deleted file mode 100644
index 02f1b24a..00000000
--- a/examples/self_build_example.py
+++ /dev/null
@@ -1,20 +0,0 @@
-import babyagi
-import os
-
-# Add OpenAI key to enable automated descriptions and embedding of functions.
-babyagi.add_key_wrapper('openai_api_key',os.environ['OPENAI_API_KEY'])
-
-# Load below function packs to play with experimental self-building functions
-babyagi.load_functions("drafts/code_writing_functions")
-babyagi.load_functions("drafts/self_build")
-
-
-babyagi.self_build("A growth marketer at an enterprise SaaS company.")
-
-@app.route('/')
-def home():
- return f"Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
diff --git a/examples/simple_example.py b/examples/simple_example.py
deleted file mode 100644
index accc1508..00000000
--- a/examples/simple_example.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# this is a simple example of registering two functions into babyagi, executing the function stored in the database, and loading the dashboard
-
-import babyagi
-import os
-
-# Add OpenAI key to enable automated descriptions and embedding of functions.
-babyagi.add_key_wrapper('openai_api_key',os.environ['OPENAI_API_KEY'])
-
-@babyagi.register_function()
-def world():
- return "world"
-
-@babyagi.register_function(dependencies=["world"])
-def hello_world():
- x = world()
- return f"Hello {x}!"
-
-print(hello_world())
-
-@app.route('/')
-def home():
- return f"Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
diff --git a/examples/trigger_example.py b/examples/trigger_example.py
deleted file mode 100644
index 09b25057..00000000
--- a/examples/trigger_example.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import babyagi
-
-@babyagi.register_function()
-def function_a():
- print("Result from function A")
- return "Result from function A"
-
-@babyagi.register_function(triggers=['function_a'])
-def function_b(input_data):
- print(f"Function B triggered with input: {input_data}")
- return f"Function B triggered with input: {input_data}"
-
-function_a()
-
-@app.route('/')
-def home():
- return f"Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
\ No newline at end of file
diff --git a/extensions/__init__.py b/extensions/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/extensions/argparseext.py b/extensions/argparseext.py
new file mode 100644
index 00000000..752390cc
--- /dev/null
+++ b/extensions/argparseext.py
@@ -0,0 +1,123 @@
+import os
+import sys
+import importlib
+import argparse
+
+def can_import(module_name):
+ try:
+ importlib.import_module(module_name)
+ return True
+ except ImportError:
+ return False
+
+# Extract the env filenames in the -e flag only
+# Ignore any other arguments
+def parse_dotenv_extensions(argv):
+ env_argv = []
+ if '-e' in argv:
+ tmp_argv = argv[argv.index('-e') + 1:]
+ parsed_args = []
+ for arg in tmp_argv:
+ if arg.startswith('-'):
+ break
+ parsed_args.append(arg)
+ env_argv = ['-e'] + parsed_args
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-e', '--env', nargs='+', help='''
+ filenames for additional env variables to load
+ ''', default=os.getenv("DOTENV_EXTENSIONS", "").split(' '))
+
+ return parser.parse_args(env_argv).env
+
+def parse_arguments():
+ dotenv_extensions = parse_dotenv_extensions(sys.argv)
+ # Check if we need to load any additional env files
+ # This allows us to override the default .env file
+ # and update the default values for any command line arguments
+ if dotenv_extensions:
+ from extensions.dotenvext import load_dotenv_extensions
+ load_dotenv_extensions(parse_dotenv_extensions(sys.argv))
+
+ # Now parse the full command line arguments
+ parser = argparse.ArgumentParser(
+ add_help=False,
+ )
+ parser.add_argument('objective', nargs='*', metavar='', help='''
+ main objective description. Doesn\'t need to be quoted.
+ if not specified, get objective from environment.
+ ''', default=[os.getenv("OBJECTIVE", "")])
+ parser.add_argument('-n', '--name', required=False, help='''
+ instance name.
+ if not specified, get the instance name from environment.
+ ''', default=os.getenv("INSTANCE_NAME", os.getenv("BABY_NAME", "BabyAGI")))
+ parser.add_argument('-m', '--mode', choices=['n', 'none', 'l', 'local', 'd', 'distributed'], help='''
+ cooperative mode type
+ ''', default='none')
+ group = parser.add_mutually_exclusive_group()
+ group.add_argument('-t', '--task', metavar='', help='''
+ initial task description. must be quoted.
+ if not specified, get initial_task from environment.
+ ''', default=os.getenv("INITIAL_TASK", os.getenv("FIRST_TASK", "")))
+ group.add_argument('-j', '--join', action='store_true', help='''
+ join an existing objective.
+ install cooperative requirements.
+ ''')
+ group2 = parser.add_mutually_exclusive_group()
+ group2.add_argument('-4', '--gpt-4', dest='llm_model', action='store_const', const="gpt-4", help='''
+ use GPT-4 instead of the default model.
+ ''')
+ group2.add_argument('-l', '--llama', dest='llm_model', action='store_const', const="llama", help='''
+ use LLaMa instead of the default model. Requires llama.cpp.
+ ''')
+ # This will parse -e again, which we want, because we need
+ # to load those in the main file later as well
+ parser.add_argument('-e', '--env', nargs='+', help='''
+ filenames for additional env variables to load
+ ''', default=os.getenv("DOTENV_EXTENSIONS", "").split(' '))
+ parser.add_argument('-h', '-?', '--help', action='help', help='''
+ show this help message and exit
+ ''')
+
+ args = parser.parse_args()
+
+ llm_model = args.llm_model if args.llm_model else os.getenv("LLM_MODEL", os.getenv("OPENAI_API_MODEL", "gpt-3.5-turbo")).lower()
+
+ dotenv_extensions = args.env
+
+ instance_name = args.name
+ if not instance_name:
+ print("\033[91m\033[1m" + "BabyAGI instance name missing\n" + "\033[0m\033[0m")
+ parser.print_help()
+ parser.exit()
+
+ module_name = "ray"
+ cooperative_mode = args.mode
+ if cooperative_mode in ['l', 'local'] and not can_import(module_name):
+ print("\033[91m\033[1m"+f"Local cooperative mode requires package {module_name}\nInstall: pip install -r extensions/requirements.txt\n" + "\033[0m\033[0m")
+ parser.print_help()
+ parser.exit()
+ elif cooperative_mode in ['d', 'distributed']:
+ print("\033[91m\033[1m" + "Distributed cooperative mode is not implemented yet\n" + "\033[0m\033[0m")
+ parser.print_help()
+ parser.exit()
+
+ join_existing_objective = args.join
+ if join_existing_objective and cooperative_mode in ['n', 'none']:
+ print("\033[91m\033[1m"+f"Joining existing objective requires local or distributed cooperative mode\n" + "\033[0m\033[0m")
+ parser.print_help()
+ parser.exit()
+
+ objective = ' '.join(args.objective).strip()
+ if not objective:
+ print("\033[91m\033[1m" + "No objective specified or found in environment.\n" + "\033[0m\033[0m")
+ parser.print_help()
+ parser.exit()
+
+ initial_task = args.task
+ if not initial_task and not join_existing_objective:
+ print("\033[91m\033[1m" + "No initial task specified or found in environment.\n" + "\033[0m\033[0m")
+ parser.print_help()
+ parser.exit()
+
+ return objective, initial_task, llm_model, dotenv_extensions, instance_name, cooperative_mode, join_existing_objective
\ No newline at end of file
diff --git a/extensions/dotenvext.py b/extensions/dotenvext.py
new file mode 100644
index 00000000..0db80aea
--- /dev/null
+++ b/extensions/dotenvext.py
@@ -0,0 +1,5 @@
+from dotenv import load_dotenv
+
+def load_dotenv_extensions(dotenv_files):
+ for dotenv_file in dotenv_files:
+ load_dotenv(dotenv_file)
diff --git a/extensions/human_mode.py b/extensions/human_mode.py
new file mode 100644
index 00000000..4d41c25e
--- /dev/null
+++ b/extensions/human_mode.py
@@ -0,0 +1,9 @@
+import sys
+
+def user_input_await(prompt: str) -> str:
+ print("\033[94m\033[1m" + "\n> COPY FOLLOWING TEXT TO CHATBOT\n" + "\033[0m\033[0m")
+ print(prompt)
+ print("\033[91m\033[1m" + "\n AFTER PASTING, PRESS: (ENTER), (CTRL+Z), (ENTER) TO FINISH\n" + "\033[0m\033[0m")
+ print("\033[96m\033[1m" + "\n> PASTE YOUR RESPONSE:\n" + "\033[0m\033[0m")
+ input_text = sys.stdin.read()
+ return input_text.strip()
\ No newline at end of file
diff --git a/extensions/pinecone_storage.py b/extensions/pinecone_storage.py
new file mode 100644
index 00000000..5e8f697b
--- /dev/null
+++ b/extensions/pinecone_storage.py
@@ -0,0 +1,70 @@
+from typing import Dict, List
+import importlib
+import openai
+import pinecone
+import re
+
+def can_import(module_name):
+ try:
+ importlib.import_module(module_name)
+ return True
+ except ImportError:
+ return False
+
+assert (
+ can_import("pinecone")
+), "\033[91m\033[1m"+"Pinecone storage requires package pinecone-client.\nInstall: pip install -r extensions/requirements.txt"
+
+class PineconeResultsStorage:
+ def __init__(self, openai_api_key: str, pinecone_api_key: str, pinecone_environment: str, llm_model: str, llama_model_path: str, results_store_name: str, objective: str):
+ openai.api_key = openai_api_key
+ pinecone.init(api_key=pinecone_api_key, environment=pinecone_environment)
+
+ # Pinecone namespaces are only compatible with ascii characters (used in query and upsert)
+ self.namespace = re.sub(re.compile('[^\x00-\x7F]+'), '', objective)
+
+ self.llm_model = llm_model
+ self.llama_model_path = llama_model_path
+
+ results_store_name = results_store_name
+ dimension = 1536 if not self.llm_model.startswith("llama") else 5120
+ metric = "cosine"
+ pod_type = "p1"
+ if results_store_name not in pinecone.list_indexes():
+ pinecone.create_index(
+ results_store_name, dimension=dimension, metric=metric, pod_type=pod_type
+ )
+
+ self.index = pinecone.Index(results_store_name)
+ index_stats_response = self.index.describe_index_stats()
+ assert dimension == index_stats_response['dimension'], "Dimension of the index does not match the dimension of the LLM embedding"
+
+ def add(self, task: Dict, result: str, result_id: int):
+ vector = self.get_embedding(
+ result
+ )
+ self.index.upsert(
+ [(result_id, vector, {"task": task["task_name"], "result": result})], namespace=self.namespace
+ )
+
+ def query(self, query: str, top_results_num: int) -> List[dict]:
+ query_embedding = self.get_embedding(query)
+ results = self.index.query(query_embedding, top_k=top_results_num, include_metadata=True, namespace=self.namespace)
+ sorted_results = sorted(results.matches, key=lambda x: x.score, reverse=True)
+ return [(str(item.metadata["task"])) for item in sorted_results]
+
+ # Get embedding for the text
+ def get_embedding(self, text: str) -> list:
+ text = text.replace("\n", " ")
+
+ if self.llm_model.startswith("llama"):
+ from llama_cpp import Llama
+
+ llm_embed = Llama(
+ model_path=self.llama_model_path,
+ n_ctx=2048, n_threads=4,
+ embedding=True, use_mlock=True,
+ )
+ return llm_embed.embed(text)
+
+ return openai.Embedding.create(input=[text], model="text-embedding-ada-002")["data"][0]["embedding"]
diff --git a/extensions/ray_objectives.py b/extensions/ray_objectives.py
new file mode 100644
index 00000000..7fcd037f
--- /dev/null
+++ b/extensions/ray_objectives.py
@@ -0,0 +1,41 @@
+import logging
+import ray
+from collections import deque
+
+ACTOR_NAME="BabyAGI Objectives"
+
+try:
+ ray.init(address="auto", namespace="babyagi", logging_level=logging.FATAL, ignore_reinit_error=True)
+except:
+ ray.init(namespace="babyagi", logging_level=logging.FATAL, ignore_reinit_error=True)
+
+@ray.remote
+class CooperativeObjectivesListStorageActor:
+ def __init__(self):
+ self.objectives = deque([])
+
+ def append(self, objective: str):
+ if not objective in self.objectives:
+ self.objectives.append(objective)
+
+ def is_empty(self):
+ return False if self.objectives else True
+
+ def get_objective_names(self):
+ return [t for t in self.objectives]
+
+class CooperativeObjectivesListStorage:
+ def __init__(self):
+ try:
+ self.actor = ray.get_actor(name=ACTOR_NAME, namespace="babyagi")
+ except ValueError:
+ self.actor = CooperativeObjectivesListStorageActor.options(name=ACTOR_NAME, namespace="babyagi", lifetime="detached").remote()
+
+ def append(self, objective: str):
+ self.actor.append.remote(objective)
+
+ def is_empty(self):
+ return ray.get(self.actor.is_empty.remote())
+
+ def get_objective_names(self):
+ return ray.get(self.actor.get_objective_names.remote())
diff --git a/extensions/ray_tasks.py b/extensions/ray_tasks.py
new file mode 100644
index 00000000..ba49b510
--- /dev/null
+++ b/extensions/ray_tasks.py
@@ -0,0 +1,69 @@
+import sys
+import logging
+import ray
+from collections import deque
+from typing import Dict, List
+
+from pathlib import Path
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from extensions.ray_objectives import CooperativeObjectivesListStorage
+
+try:
+ ray.init(address="auto", namespace="babyagi", logging_level=logging.FATAL, ignore_reinit_error=True)
+except:
+ ray.init(namespace="babyagi", logging_level=logging.FATAL, ignore_reinit_error=True)
+
+@ray.remote
+class CooperativeTaskListStorageActor:
+ def __init__(self):
+ self.tasks = deque([])
+ self.task_id_counter = 0
+
+ def append(self, task: Dict):
+ self.tasks.append(task)
+
+ def replace(self, tasks: List[Dict]):
+ self.tasks = deque(tasks)
+
+ def popleft(self):
+ return self.tasks.popleft()
+
+ def is_empty(self):
+ return False if self.tasks else True
+
+ def next_task_id(self):
+ self.task_id_counter += 1
+ return self.task_id_counter
+
+ def get_task_names(self):
+ return [t["task_name"] for t in self.tasks]
+
+class CooperativeTaskListStorage:
+ def __init__(self, name: str):
+ self.name = name
+
+ try:
+ self.actor = ray.get_actor(name=self.name, namespace="babyagi")
+ except ValueError:
+ self.actor = CooperativeTaskListStorageActor.options(name=self.name, namespace="babyagi", lifetime="detached").remote()
+
+ objectives = CooperativeObjectivesListStorage()
+ objectives.append(self.name)
+
+ def append(self, task: Dict):
+ self.actor.append.remote(task)
+
+ def replace(self, tasks: List[Dict]):
+ self.actor.replace.remote(tasks)
+
+ def popleft(self):
+ return ray.get(self.actor.popleft.remote())
+
+ def is_empty(self):
+ return ray.get(self.actor.is_empty.remote())
+
+ def next_task_id(self):
+ return ray.get(self.actor.next_task_id.remote())
+
+ def get_task_names(self):
+ return ray.get(self.actor.get_task_names.remote())
diff --git a/extensions/requirements.txt b/extensions/requirements.txt
new file mode 100644
index 00000000..9aaa511f
--- /dev/null
+++ b/extensions/requirements.txt
@@ -0,0 +1,4 @@
+ray==2.6.3
+pinecone-client==2.2.1
+llama-cpp-python>=0.1.35
+weaviate-client>=3.16.1
\ No newline at end of file
diff --git a/extensions/weaviate_storage.py b/extensions/weaviate_storage.py
new file mode 100644
index 00000000..cb562244
--- /dev/null
+++ b/extensions/weaviate_storage.py
@@ -0,0 +1,139 @@
+import importlib
+import logging
+import re
+from typing import Dict, List
+
+import openai
+import weaviate
+from weaviate.embedded import EmbeddedOptions
+
+
+def can_import(module_name):
+ try:
+ importlib.import_module(module_name)
+ return True
+ except ImportError:
+ return False
+
+
+assert can_import("weaviate"), (
+ "\033[91m\033[1m"
+ + "Weaviate storage requires package weaviate-client.\nInstall: pip install -r extensions/requirements.txt"
+)
+
+
+def create_client(
+ weaviate_url: str, weaviate_api_key: str, weaviate_use_embedded: bool
+):
+ if weaviate_use_embedded:
+ client = weaviate.Client(embedded_options=EmbeddedOptions())
+ else:
+ auth_config = (
+ weaviate.auth.AuthApiKey(api_key=weaviate_api_key)
+ if weaviate_api_key
+ else None
+ )
+ client = weaviate.Client(weaviate_url, auth_client_secret=auth_config)
+
+ return client
+
+
+class WeaviateResultsStorage:
+ schema = {
+ "properties": [
+ {"name": "result_id", "dataType": ["string"]},
+ {"name": "task", "dataType": ["string"]},
+ {"name": "result", "dataType": ["text"]},
+ ]
+ }
+
+ def __init__(
+ self,
+ openai_api_key: str,
+ weaviate_url: str,
+ weaviate_api_key: str,
+ weaviate_use_embedded: bool,
+ llm_model: str,
+ llama_model_path: str,
+ results_store_name: str,
+ objective: str,
+ ):
+ openai.api_key = openai_api_key
+ self.client = create_client(
+ weaviate_url, weaviate_api_key, weaviate_use_embedded
+ )
+ self.index_name = None
+ self.create_schema(results_store_name)
+
+ self.llm_model = llm_model
+ self.llama_model_path = llama_model_path
+
+ def create_schema(self, results_store_name: str):
+ valid_class_name = re.compile(r"^[A-Z][a-zA-Z0-9_]*$")
+ if not re.match(valid_class_name, results_store_name):
+ raise ValueError(
+ f"Invalid index name: {results_store_name}. "
+ "Index names must start with a capital letter and "
+ "contain only alphanumeric characters and underscores."
+ )
+
+ self.schema["class"] = results_store_name
+ if self.client.schema.contains(self.schema):
+ logging.info(
+ f"Index named {results_store_name} already exists. Reusing it."
+ )
+ else:
+ logging.info(f"Creating index named {results_store_name}")
+ self.client.schema.create_class(self.schema)
+
+ self.index_name = results_store_name
+
+ def add(self, task: Dict, result: Dict, result_id: int, vector: List):
+ enriched_result = {"data": result}
+ vector = self.get_embedding(enriched_result["data"])
+
+ with self.client.batch as batch:
+ data_object = {
+ "result_id": result_id,
+ "task": task["task_name"],
+ "result": result,
+ }
+ batch.add_data_object(
+ data_object=data_object, class_name=self.index_name, vector=vector
+ )
+
+ def query(self, query: str, top_results_num: int) -> List[dict]:
+ query_embedding = self.get_embedding(query)
+
+ results = (
+ self.client.query.get(self.index_name, ["task"])
+ .with_hybrid(query=query, alpha=0.5, vector=query_embedding)
+ .with_limit(top_results_num)
+ .do()
+ )
+
+ return self._extract_tasks(results)
+
+ def _extract_tasks(self, data):
+ task_data = data.get("data", {}).get("Get", {}).get(self.index_name, [])
+ return [item["task"] for item in task_data]
+
+ # Get embedding for the text
+ def get_embedding(self, text: str) -> list:
+ text = text.replace("\n", " ")
+
+ if self.llm_model.startswith("llama"):
+ from llama_cpp import Llama
+
+ llm_embed = Llama(
+ model_path=self.llama_model_path,
+ n_ctx=2048,
+ n_threads=4,
+ embedding=True,
+ use_mlock=True,
+ )
+ return llm_embed.embed(text)
+
+ return openai.Embedding.create(input=[text], model="text-embedding-ada-002")[
+ "data"
+ ][0]["embedding"]
diff --git a/main.py b/main.py
deleted file mode 100644
index c337239a..00000000
--- a/main.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import babyagi
-import os
-
-
-app = babyagi.create_app('/dashboard')
-
-# Add OpenAI key to enable automated descriptions and embedding of functions.
-babyagi.add_key_wrapper('openai_api_key',os.environ['OPENAI_API_KEY'])
-
-
-@app.route('/')
-def home():
- return f"Welcome to the main app. Visit /dashboard for BabyAGI dashboard."
-
-if __name__ == "__main__":
- app.run(host='0.0.0.0', port=8080)
diff --git a/node/.env.example b/node/.env.example
new file mode 100644
index 00000000..4ed133ea
--- /dev/null
+++ b/node/.env.example
@@ -0,0 +1,16 @@
+# 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=
+OPENAI_API_MODEL=gpt-3.5-turbo # alternatively, gpt-4, text-davinci-003, etc
+
+# Collection CONFIG
+TABLE_NAME=test-collection
+
+# INSTANCE CONFIG
+BABY_NAME=BabyAGI
+
diff --git a/node/README.md b/node/README.md
new file mode 100644
index 00000000..829caf35
--- /dev/null
+++ b/node/README.md
@@ -0,0 +1,71 @@
+# node-chroma babyagi
+
+# Objective
+
+This Node script is an example of an AI-powered task management system. The system uses OpenAI and Chroma APIs to create, prioritize, and execute tasks. The main idea behind this system is that it creates tasks based on the result of previous tasks and a predefined objective. The script then uses OpenAI's natural language processing (NLP) capabilities to create new tasks based on the objective, and Chroma to store and retrieve task results for context. This is a paired-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023).
+
+This README will cover the following:
+
+- How the script works
+
+- How to use the script
+- Warning about running the script continuously
+
+# How It Works
+
+The script works by running an infinite loop that does the following steps:
+
+1. Pulls the first task from the task list.
+2. Sends the task to the execution agent, which uses OpenAI's API to complete the task based on the context.
+3. Enriches the result and stores it in [Chroma](docs.trychroma.com).
+4. Creates new tasks and reprioritizes the task list based on the objective and the result of the previous task.
+ The execution_agent() function is where the OpenAI API is used. It takes two parameters: the objective and the task. It then sends a prompt to OpenAI's API, which returns the result of the task. The prompt consists of a description of the AI system's task, the objective, and the task itself. The result is then returned as a string.
+
+The task_creation_agent() function is where OpenAI's API is used to create new tasks based on the objective and the result of the previous task. The function takes four parameters: the objective, the result of the previous task, the task description, and the current task list. It then sends a prompt to OpenAI's API, which returns a list of new tasks as strings. The function then returns the new tasks as a list of dictionaries, where each dictionary contains the name of the task.
+
+The prioritization_agent() function is where OpenAI's API is used to reprioritize the task list. The function takes one parameter, the ID of the current task. It sends a prompt to OpenAI's API, which returns the reprioritized task list as a numbered list.
+
+Finally, the script uses Chroma to store and retrieve task results for context. The script creates a Chroma collection based on the table name specified in the TABLE_NAME variable. Chroma is then used to store the results of the task in the collection, along with the task name and any additional metadata.
+
+# How to Use
+
+To use the script, you will need to follow these steps:
+
+1. Install the required packages: `npm install`
+2. Install chroma in this directory (based on the Chroma [docs](https://docs.trychroma.com/getting-started)) :
+ ```
+ git clone git@github.com:chroma-core/chroma.git
+ ```
+3. Make sure Docker is running on your machine
+4. Set your OpenAI and in the OPENAI_API_KEY variables.
+5. Set your OpenAI API key in the OPENAI_API_KEY and OPENAPI_API_MODEL variables.
+6. Set the name of the table where the task results will be stored in the TABLE_NAME variable.
+7. Run the script with 'npm run babyagi'. This will handle 'docker compose up.'
+8. Provide the objective of the task management system when prompted.
+9. Provide the objective of the task management system when prompted.
+
+# Warning
+
+This script is designed to be run continuously as part of a task management system. Running this script continuously can result in high API usage, so please use it responsibly. Additionally, the script requires the OpenAI and Pinecone APIs to be set up correctly, so make sure you have set up the APIs before running the script.
+
+# Backstory
+
+BabyAGI is a paired-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) shared on Twitter. This version is down to 140 lines: 13 comments, 22 blank, 105 code. The name of the repo came up in the reaction to the original autonomous agent - the author does not mean to imply that this is AGI.
+
+# TODO
+
+- [x] Implement BabyAGI in nodex
+- [x] Switch Pinecome to Chroma
+- [ ] Add LLaMA support
+- [ ] Allow users to modify model params
+- [ ] Support command line args
+- [ ] Allow agent to request additional input from user ( could be an interesting strategy to mitigate looping )
+
+Made with love by :
+
+- [@yoheinakajima](https://twitter.com/yoheinakajima) (0->1), who happens to be a VC - so if you use this build a startup, ping him!
+
+Contributions from:
+
+- [@anton](https://twitter.com/atroyn) (pinecone->chroma), who happens to be a founder at [Chroma](https://www.trychroma.com/)
+- [@aidanjrauscher](https://twitter.com/aidanjrauscher) (python->node), who happens to be trying to find a job
diff --git a/node/babyagi.js b/node/babyagi.js
new file mode 100644
index 00000000..1ee23d72
--- /dev/null
+++ b/node/babyagi.js
@@ -0,0 +1,242 @@
+import { Configuration, OpenAIApi } from "openai"
+import { ChromaClient, OpenAIEmbeddingFunction } from "chromadb"
+import prompt from "prompt-sync"
+import assert from "assert"
+import * as dotenv from "dotenv"
+dotenv.config()
+
+// const client = new ChromaClient("http://localhost:8000")
+
+// API Keys
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY || ""
+assert(OPENAI_API_KEY, "OPENAI_API_KEY environment variable is missing from .env")
+
+const OPENAI_API_MODEL = process.env.OPENAI_API_MODEL || "gpt-3.5-turbo"
+
+// Table config
+const TABLE_NAME = process.env.TABLE_NAME || ""
+assert(TABLE_NAME, "TABLE_NAME environment variable is missing from .env")
+
+// Run config
+const BABY_NAME = process.env.BABY_NAME || "BabyAGI"
+
+// Goal config
+const p = prompt()
+const OBJECTIVE = p("What is BabyAGI's objective? ")
+const INITIAL_TASK = p("What is the initial task to complete the objective? ")
+assert(OBJECTIVE, "No objective provided.")
+assert (INITIAL_TASK, "No initial task provided.")
+
+console.log('\x1b[95m\x1b[1m\n*****CONFIGURATION*****\n\x1b[0m\x1b[0m')
+console.log(`Name: ${BABY_NAME}`)
+console.log(`LLM: ${OPENAI_API_MODEL}`)
+
+if (OPENAI_API_MODEL.toLowerCase().includes("gpt-4")){
+ console.log("\x1b[91m\x1b[1m\n*****USING GPT-4. POTENTIALLY EXPENSIVE. MONITOR YOUR COSTS*****\x1b[0m\x1b[0m")
+}
+
+console.log("\x1b[94m\x1b[1m" + "\n*****OBJECTIVE*****\n" + "\x1b[0m\x1b[0m")
+console.log(`${OBJECTIVE}`)
+
+console.log(`\x1b[93m\x1b[1m \nInitial task: \x1b[0m\x1b[0m ${INITIAL_TASK}`)
+
+// Define OpenAI embedding function using Chroma
+const embeddingFunction = new OpenAIEmbeddingFunction(OPENAI_API_KEY)
+
+// Configure OpenAI
+const configuration = new Configuration({
+ apiKey: OPENAI_API_KEY,
+});
+const openai = new OpenAIApi(configuration);
+
+//Task List
+var taskList = []
+
+// Connect to chromadb and create/get collection
+const chromaConnect = async ()=>{
+ const chroma = new ChromaClient("http://localhost:8000")
+ const metric = "cosine"
+ const collections = await chroma.listCollections()
+ const collectionNames = collections.map((c)=>c.name)
+ if(collectionNames.includes(TABLE_NAME)){
+ const collection = await chroma.getCollection(TABLE_NAME, embeddingFunction)
+ return collection
+ }
+ else{
+ const collection = await chroma.createCollection(
+ TABLE_NAME,
+ {
+ "hnsw:space": metric
+ },
+ embeddingFunction
+ )
+ return collection
+ }
+}
+
+const add_task = (task)=>{ taskList.push(task) }
+
+const clear_tasks = ()=>{ taskList = [] }
+
+const get_ada_embedding = async (text)=>{
+ text = text.replace("\n", " ")
+ const embedding = await embeddingFunction.generate(text)
+ return embedding
+}
+
+const openai_completion = async (prompt, temperature=0.5, maxTokens=100)=>{
+ if(OPENAI_API_MODEL.startsWith("gpt-")){
+ const messages = [{"role": "system", "content": prompt}]
+ const response = await openai.createChatCompletion({
+ model: OPENAI_API_MODEL,
+ messages: messages,
+ max_tokens: maxTokens,
+ temperature: temperature,
+ n: 1,
+ stop: null
+ })
+ return response.data.choices[0].message.content.trim()
+ }
+ else {
+ const response = await openai.createCompletion({
+ model: OPENAI_API_MODEL,
+ prompt: prompt,
+ max_tokens: maxTokens,
+ temperature: temperature,
+ top_p: 1,
+ frequency_penalty: 0,
+ presence_penalty: 0
+ })
+ return response.data.choices[0].text.trim()
+ }
+}
+
+const task_creation_agent = async (objective, result, task_description, taskList)=>{
+ const prompt = `
+ You are an task creation AI that uses the result of an execution agent to create new tasks with the following objective: ${objective},
+ The last completed task has the result: ${result}.
+ This result was based on this task description: ${task_description}.
+ These are incomplete tasks: ${taskList.map(task=>`${task.taskId}: ${task.taskName}`).join(', ')}.
+ Based on the result, create new tasks to be completed by the AI system that do not overlap with incomplete tasks.
+ Return the tasks as an array.`
+ const response = await openai_completion(prompt)
+ const newTasks = response.trim().includes("\n") ? response.trim().split("\n") : [response.trim()];
+ return newTasks.map(taskName => ({ taskName: taskName }));
+}
+
+
+
+const prioritization_agent = async (taskId)=>{
+ const taskNames = taskList.map((task)=>task.taskName)
+ const nextTaskId = taskId+1
+ const prompt = `
+ You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing the following tasks: ${taskNames}.
+ Consider the ultimate objective of your team:${OBJECTIVE}. Do not remove any tasks. Return the result as a numbered list, like:
+ #. First task
+ #. Second task
+ Start the task list with number ${nextTaskId}.`
+ const response = await openai_completion(prompt)
+ const newTasks = response.trim().includes("\n") ? response.trim().split("\n") : [response.trim()];
+ clear_tasks()
+ newTasks.forEach((newTask)=>{
+ const newTaskParts = newTask.trim().split(/\.(?=\s)/)
+ if (newTaskParts.length == 2){
+ const newTaskId = newTaskParts[0].trim()
+ const newTaskName = newTaskParts[1].trim()
+ add_task({
+ taskId: newTaskId,
+ taskName: newTaskName
+ })
+ }
+ })
+}
+
+const execution_agent = async (objective, task, chromaCollection)=>{
+ const context = context_agent(objective, 5, chromaCollection)
+ const prompt = `
+ You are an AI who performs one task based on the following objective: ${objective}.\n
+ Take into account these previously completed tasks: ${context}.\n
+ Your task: ${task}\nResponse:`
+ const response = await openai_completion(prompt, undefined, 2000)
+ return response
+}
+
+const context_agent = async (query, topResultsNum, chromaCollection)=>{
+ const count = await chromaCollection.count()
+ if (count == 0){
+ return []
+ }
+ const results = await chromaCollection.query(
+ undefined,
+ Math.min(topResultsNum, count),
+ undefined,
+ query,
+ )
+ return results.metadatas[0].map(item=>item.task)
+}
+
+function sleep(ms) {
+ return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+(async()=>{
+ const initialTask = {
+ taskId: 1,
+ taskName: INITIAL_TASK
+ }
+ add_task(initialTask)
+ const chromaCollection = await chromaConnect()
+ var taskIdCounter = 1
+ while (true){
+ if(taskList.length>0){
+ console.log("\x1b[95m\x1b[1m"+"\n*****TASK LIST*****\n"+"\x1b[0m\x1b[0m")
+ taskList.forEach(t => {
+ console.log(" • " + t.taskName)
+ })
+
+ // Step 1: Pull the first task
+ const task = taskList.shift()
+ console.log("\x1b[92m\x1b[1m"+"\n*****NEXT TASK*****\n"+"\x1b[0m\x1b[0m")
+ console.log(task.taskId + ": " + task.taskName)
+
+ // Send to execution function to complete the task based on the context
+ const result = await execution_agent(OBJECTIVE, task.taskName, chromaCollection)
+ const currTaskId = task.taskId
+ console.log("\x1b[93m\x1b[1m"+"\nTASK RESULT\n"+"\x1b[0m\x1b[0m")
+ console.log(result)
+
+ // Step 2: Enrich result and store in Chroma
+ const enrichedResult = { data : result} // this is where you should enrich the result if needed
+ const resultId = `result_${task.taskId}`
+ const vector = enrichedResult.data // extract the actual result from the dictionary
+ const collectionLength = (await chromaCollection.get([resultId])).ids?.length
+ if(collectionLength>0){
+ await chromaCollection.update(
+ resultId,
+ undefined,
+ {task: task.taskName, result: result},
+ vector
+ )
+ }
+ else{
+ await chromaCollection.add(
+ resultId,
+ undefined,
+ {task: task.taskName, result},
+ vector
+ )
+ }
+
+ // Step 3: Create new tasks and reprioritize task list
+ const newTasks = await task_creation_agent(OBJECTIVE, enrichedResult, task.taskName, taskList.map(task=>task.taskName))
+ newTasks.forEach((task)=>{
+ taskIdCounter += 1
+ task.taskId = taskIdCounter
+ add_task(task)
+ })
+ await prioritization_agent(currTaskId)
+ await sleep(3000)
+ }
+ }
+})()
+
diff --git a/node/package-lock.json b/node/package-lock.json
new file mode 100644
index 00000000..bac09b88
--- /dev/null
+++ b/node/package-lock.json
@@ -0,0 +1,154 @@
+{
+ "name": "babyagi",
+ "version": "1.0.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "babyagi",
+ "version": "1.0.0",
+ "license": "ISC",
+ "dependencies": {
+ "chromadb": "^1.4.1",
+ "dotenv": "^16.0.3",
+ "openai": "^3.2.1",
+ "prompt-sync": "^4.2.0"
+ }
+ },
+ "node_modules/ansi-regex": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+ "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+ },
+ "node_modules/axios": {
+ "version": "0.26.1",
+ "resolved": "https://registry.npmjs.org/axios/-/axios-0.26.1.tgz",
+ "integrity": "sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==",
+ "dependencies": {
+ "follow-redirects": "^1.14.8"
+ }
+ },
+ "node_modules/chromadb": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/chromadb/-/chromadb-1.4.1.tgz",
+ "integrity": "sha512-vRcig4CJxJXs++cKMt9tHmk9YjQprxzLK9sVYD6iXfqRJBoXeoFzk/RS95Dz1J6/7aSfBwDsyx3AE2ePP9FnYA==",
+ "dependencies": {
+ "axios": "^0.26.0"
+ }
+ },
+ "node_modules/combined-stream": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+ "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+ "dependencies": {
+ "delayed-stream": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/dotenv": {
+ "version": "16.0.3",
+ "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.0.3.tgz",
+ "integrity": "sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ==",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/follow-redirects": {
+ "version": "1.15.2",
+ "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
+ "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/RubenVerborgh"
+ }
+ ],
+ "engines": {
+ "node": ">=4.0"
+ },
+ "peerDependenciesMeta": {
+ "debug": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/form-data": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+ "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+ "dependencies": {
+ "asynckit": "^0.4.0",
+ "combined-stream": "^1.0.8",
+ "mime-types": "^2.1.12"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/mime-db": {
+ "version": "1.52.0",
+ "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+ "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mime-types": {
+ "version": "2.1.35",
+ "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+ "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+ "dependencies": {
+ "mime-db": "1.52.0"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/openai": {
+ "version": "3.2.1",
+ "resolved": "https://registry.npmjs.org/openai/-/openai-3.2.1.tgz",
+ "integrity": "sha512-762C9BNlJPbjjlWZi4WYK9iM2tAVAv0uUp1UmI34vb0CN5T2mjB/qM6RYBmNKMh/dN9fC+bxqPwWJZUTWW052A==",
+ "dependencies": {
+ "axios": "^0.26.0",
+ "form-data": "^4.0.0"
+ }
+ },
+ "node_modules/prompt-sync": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/prompt-sync/-/prompt-sync-4.2.0.tgz",
+ "integrity": "sha512-BuEzzc5zptP5LsgV5MZETjDaKSWfchl5U9Luiu8SKp7iZWD5tZalOxvNcZRwv+d2phNFr8xlbxmFNcRKfJOzJw==",
+ "dependencies": {
+ "strip-ansi": "^5.0.0"
+ }
+ },
+ "node_modules/strip-ansi": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+ "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+ "dependencies": {
+ "ansi-regex": "^4.1.0"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ }
+ }
+}
diff --git a/node/package.json b/node/package.json
new file mode 100644
index 00000000..0b771d0c
--- /dev/null
+++ b/node/package.json
@@ -0,0 +1,25 @@
+{
+ "name": "babyagi",
+ "version": "1.0.0",
+ "description": "babyagi",
+ "main": "babyagi.js",
+ "type": "module",
+ "author": {
+ "name": "Yohei Nakajima",
+ "url": "https://twitter.com/yoheinakajima"
+ },
+ "scripts": {
+ "babyagi": "node babyagi.js",
+ "start": "npm run chroma-up && node babyagi.js",
+ "chroma-up": "docker-compose -f ./chroma/docker-compose.yml up -d --build",
+ "chroma-down": "docker-compose -f ./chroma/docker-compose.yml down"
+ },
+ "keywords": [],
+ "license": "ISC",
+ "dependencies": {
+ "chromadb": "^1.4.1",
+ "dotenv": "^16.0.3",
+ "openai": "^3.2.1",
+ "prompt-sync": "^4.2.0"
+ }
+}
diff --git a/poetry.lock b/poetry.lock
deleted file mode 100644
index 63caf497..00000000
--- a/poetry.lock
+++ /dev/null
@@ -1,221 +0,0 @@
-# This file is automatically @generated by Poetry 1.5.5 and should not be changed by hand.
-
-[[package]]
-name = "antiorm"
-version = "1.2.1"
-description = "A Pythonic Helper for DBAPI-2.0 SQL Access"
-optional = false
-python-versions = "*"
-files = [
- {file = "antiorm-1.2.1.tar.gz", hash = "sha256:96eb1841ce5163db4cf1dc13f4499ec2d7cffc190cf724b78ffdd3e6b7c4ff93"},
-]
-
-[[package]]
-name = "blinker"
-version = "1.8.2"
-description = "Fast, simple object-to-object and broadcast signaling"
-optional = false
-python-versions = ">=3.8"
-files = [
- {file = "blinker-1.8.2-py3-none-any.whl", hash = "sha256:1779309f71bf239144b9399d06ae925637cf6634cf6bd131104184531bf67c01"},
- {file = "blinker-1.8.2.tar.gz", hash = "sha256:8f77b09d3bf7c795e969e9486f39c2c5e9c39d4ee07424be2bc594ece9642d83"},
-]
-
-[[package]]
-name = "click"
-version = "8.1.7"
-description = "Composable command line interface toolkit"
-optional = false
-python-versions = ">=3.7"
-files = [
- {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
- {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "platform_system == \"Windows\""}
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-description = "Cross-platform colored terminal text."
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
-files = [
- {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
- {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
-]
-
-[[package]]
-name = "db"
-version = "0.1.1"
-description = "Databases for Humans"
-optional = false
-python-versions = "*"
-files = [
- {file = "db-0.1.1.tar.gz", hash = "sha256:980e772f15c1161d3b287ffec4f144e40961b0b3e6d5102809577870bf6c5808"},
-]
-
-[package.dependencies]
-antiorm = "*"
-
-[[package]]
-name = "flask"
-version = "3.0.3"
-description = "A simple framework for building complex web applications."
-optional = false
-python-versions = ">=3.8"
-files = [
- {file = "flask-3.0.3-py3-none-any.whl", hash = "sha256:34e815dfaa43340d1d15a5c3a02b8476004037eb4840b34910c6e21679d288f3"},
- {file = "flask-3.0.3.tar.gz", hash = "sha256:ceb27b0af3823ea2737928a4d99d125a06175b8512c445cbd9a9ce200ef76842"},
-]
-
-[package.dependencies]
-blinker = ">=1.6.2"
-click = ">=8.1.3"
-itsdangerous = ">=2.1.2"
-Jinja2 = ">=3.1.2"
-Werkzeug = ">=3.0.0"
-
-[package.extras]
-async = ["asgiref (>=3.2)"]
-dotenv = ["python-dotenv"]
-
-[[package]]
-name = "itsdangerous"
-version = "2.2.0"
-description = "Safely pass data to untrusted environments and back."
-optional = false
-python-versions = ">=3.8"
-files = [
- {file = "itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef"},
- {file = "itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173"},
-]
-
-[[package]]
-name = "jinja2"
-version = "3.1.4"
-description = "A very fast and expressive template engine."
-optional = false
-python-versions = ">=3.7"
-files = [
- {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"},
- {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"},
-]
-
-[package.dependencies]
-MarkupSafe = ">=2.0"
-
-[package.extras]
-i18n = ["Babel (>=2.7)"]
-
-[[package]]
-name = "markupsafe"
-version = "2.1.5"
-description = "Safely add untrusted strings to HTML/XML markup."
-optional = false
-python-versions = ">=3.7"
-files = [
- {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"},
- {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"},
- {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"},
- {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"},
- {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"},
- {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"},
- {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"},
- {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},
-]
-
-[[package]]
-name = "setuptools"
-version = "75.1.0"
-description = "Easily download, build, install, upgrade, and uninstall Python packages"
-optional = false
-python-versions = ">=3.8"
-files = [
- {file = "setuptools-75.1.0-py3-none-any.whl", hash = "sha256:35ab7fd3bcd95e6b7fd704e4a1539513edad446c097797f2985e0e4b960772f2"},
- {file = "setuptools-75.1.0.tar.gz", hash = "sha256:d59a21b17a275fb872a9c3dae73963160ae079f1049ed956880cd7c09b120538"},
-]
-
-[package.extras]
-check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.5.2)"]
-core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.collections", "jaraco.functools", "jaraco.text (>=3.7)", "more-itertools", "more-itertools (>=8.8)", "packaging", "packaging (>=24)", "platformdirs (>=2.6.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"]
-cover = ["pytest-cov"]
-doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"]
-enabler = ["pytest-enabler (>=2.2)"]
-test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"]
-type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.11.*)", "pytest-mypy"]
-
-[[package]]
-name = "werkzeug"
-version = "3.0.4"
-description = "The comprehensive WSGI web application library."
-optional = false
-python-versions = ">=3.8"
-files = [
- {file = "werkzeug-3.0.4-py3-none-any.whl", hash = "sha256:02c9eb92b7d6c06f31a782811505d2157837cea66aaede3e217c7c27c039476c"},
- {file = "werkzeug-3.0.4.tar.gz", hash = "sha256:34f2371506b250df4d4f84bfe7b0921e4762525762bbd936614909fe25cd7306"},
-]
-
-[package.dependencies]
-MarkupSafe = ">=2.1.1"
-
-[package.extras]
-watchdog = ["watchdog (>=2.3)"]
-
-[metadata]
-lock-version = "2.0"
-python-versions = ">=3.10.0,<3.12"
-content-hash = "4844ed15a3b93c780b28d726ad6b05890ab66e7bd9d5bade0a5b5083ab72c81f"
diff --git a/pyproject.toml b/pyproject.toml
deleted file mode 100644
index 1ef7a8bd..00000000
--- a/pyproject.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[tool.poetry]
-name = "python-template"
-version = "0.1.0"
-description = ""
-authors = ["Your Name "]
-
-[tool.poetry.dependencies]
-python = ">=3.10.0,<3.12"
-db = "^0.1.1"
-flask = "^3.0.3"
-werkzeug = "^3.0.4"
-setuptools = "^75.1.0"
-
-[tool.pyright]
-# https://github.com/microsoft/pyright/blob/main/docs/configuration.md
-useLibraryCodeForTypes = true
-exclude = [".cache"]
-
-[tool.ruff]
-# https://beta.ruff.rs/docs/configuration/
-select = ['E', 'W', 'F', 'I', 'B', 'C4', 'ARG', 'SIM']
-ignore = ['W291', 'W292', 'W293']
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 0486ae7b..db526cfa 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,7 @@
-Flask>=2.0.0
-sqlalchemy>=1.4,<2.0
-cryptography
-scikit-learn
-litellm
-openai
\ No newline at end of file
+argparse==1.4.0
+openai==0.27.4
+chromadb==0.4.6
+pre-commit>=3.2.0
+python-dotenv==1.0.0
+tiktoken==0.3.3
+llama-cpp-python>=0.1.42
diff --git a/self_build.png b/self_build.png
deleted file mode 100644
index 3bb4d103..00000000
Binary files a/self_build.png and /dev/null differ
diff --git a/setup.py b/setup.py
deleted file mode 100644
index b09b8be5..00000000
--- a/setup.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from setuptools import setup, find_packages
-import os
-
-# Read the long description from README.md
-with open("README.md", "r", encoding="utf-8") as fh:
- long_description = fh.read()
-
-# Read requirements from requirements.txt
-def parse_requirements(filename):
- with open(filename, "r") as f:
- lines = f.readlines()
- # Remove comments and empty lines
- return [line.strip() for line in lines if line.strip() and not line.startswith("#")]
-
-setup(
- name="babyagi", # Ensure this is the desired package name
- version="0.0.6", # Update this version appropriately
- author="Yohei Nakajima",
- author_email="babyagi@untapped.vc",
- description="A temporary description. Do not install.",
- long_description= long_description,
- long_description_content_type="text/markdown",
- url="https://github.com/yoheinakajima/babyagi", # Update if necessary
- packages=find_packages(),
- include_package_data=True, # Include package data as specified in MANIFEST.in
- classifiers=[
- "Programming Language :: Python :: 3",
- "License :: OSI Approved :: MIT License",
- "Operating System :: OS Independent",
- ],
- python_requires='>=3.6',
- install_requires=parse_requirements("requirements.txt"),
- entry_points={
- 'console_scripts': [
- 'babyagi=babyagi.main:main', # Example entry point
- ],
- },
- keywords="AGI, AI, Framework, Baby AGI",
- project_urls={ # Optional
- "Author": "https://x.com/yoheinakajima",
- },
-)
diff --git a/tools/README.md b/tools/README.md
new file mode 100644
index 00000000..75c626a7
--- /dev/null
+++ b/tools/README.md
@@ -0,0 +1,11 @@
+Monitor requires curses library. To install it on Ubuntu, run:
+
+```sh
+sudo apt update && sudo apt install libncurses5-dev libncursesw5-dev -y
+```
+
+Also, install keyboard library:
+
+```sh
+pip3 install keyboard
+```
diff --git a/tools/__init__.py b/tools/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tools/monitor.py b/tools/monitor.py
new file mode 100644
index 00000000..9ef6166a
--- /dev/null
+++ b/tools/monitor.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+import sys
+import time
+import curses
+
+from pathlib import Path
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from extensions.ray_objectives import CooperativeObjectivesListStorage
+from extensions.ray_tasks import CooperativeTaskListStorage
+
+def print_buffer(stdscr, lines):
+ stdscr.clear()
+ y = 0
+ x = 0
+ for line in lines:
+ stdscr.addstr(y, x, line)
+ y += 1
+ stdscr.refresh()
+
+def main(stdscr):
+ objectives = CooperativeObjectivesListStorage()
+ while True:
+ objectives_list = objectives.get_objective_names()
+ buffer = []
+ if not objectives_list:
+ buffer.append("No objectives")
+ for objective in objectives_list:
+ buffer.append("-----------------")
+ buffer.append(f"Objective: {objective}")
+ buffer.append("-----------------")
+ tasks = CooperativeTaskListStorage(objective)
+ tasks_list = tasks.get_task_names()
+ buffer.append(f"Tasks:")
+ for t in tasks_list:
+ buffer.append(f" * {t}")
+ buffer.append("-----------------")
+ print_buffer(stdscr, buffer)
+ time.sleep(30)
+
+curses.wrapper(main)
diff --git a/tools/results.py b/tools/results.py
new file mode 100644
index 00000000..3807aa82
--- /dev/null
+++ b/tools/results.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import os
+import argparse
+import openai
+import pinecone
+from dotenv import load_dotenv
+
+load_dotenv()
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+assert OPENAI_API_KEY, "OPENAI_API_KEY environment variable is missing from .env"
+
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY", "")
+assert PINECONE_API_KEY, "PINECONE_API_KEY environment variable is missing from .env"
+
+PINECONE_ENVIRONMENT = os.getenv("PINECONE_ENVIRONMENT", "us-east1-gcp")
+assert PINECONE_ENVIRONMENT, "PINECONE_ENVIRONMENT environment variable is missing from .env"
+
+# Table config
+PINECONE_TABLE_NAME = os.getenv("TABLE_NAME", "")
+assert PINECONE_TABLE_NAME, "TABLE_NAME environment variable is missing from .env"
+
+# Function to query records from the Pinecone index
+def query_records(index, query, top_k=1000):
+ results = index.query(query, top_k=top_k, include_metadata=True)
+ return [f"{task.metadata['task']}:\n{task.metadata['result']}\n------------------" for task in results.matches]
+
+# Get embedding for the text
+def get_ada_embedding(text):
+ text = text.replace("\n", " ")
+ return openai.Embedding.create(input=[text], model="text-embedding-ada-002")["data"][0]["embedding"]
+
+def main():
+ # Parse command-line arguments
+ parser = argparse.ArgumentParser(description="Query Pinecone index using a string.")
+ parser.add_argument('objective', nargs='*', metavar='', help='''
+ main objective description. Doesn\'t need to be quoted.
+ if not specified, get objective from environment.
+ ''', default=[os.getenv("OBJECTIVE", "")])
+ args = parser.parse_args()
+
+ # Configure OpenAI
+ openai.api_key = OPENAI_API_KEY
+
+ # Initialize Pinecone
+ pinecone.init(api_key=PINECONE_API_KEY)
+
+ # Connect to the objective index
+ index = pinecone.Index(PINECONE_TABLE_NAME)
+
+ # Query records from the index
+ query = get_ada_embedding(' '.join(args.objective).strip())
+ retrieved_tasks = query_records(index, query)
+ for r in retrieved_tasks:
+ print(r)
+
+if __name__ == "__main__":
+ main()
diff --git a/tools/results_browser.py b/tools/results_browser.py
new file mode 100644
index 00000000..caf24662
--- /dev/null
+++ b/tools/results_browser.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+import os
+import curses
+import argparse
+import openai
+import pinecone
+from dotenv import load_dotenv
+import textwrap
+
+load_dotenv()
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+assert OPENAI_API_KEY, "OPENAI_API_KEY environment variable is missing from .env"
+
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY", "")
+assert PINECONE_API_KEY, "PINECONE_API_KEY environment variable is missing from .env"
+
+PINECONE_ENVIRONMENT = os.getenv("PINECONE_ENVIRONMENT", "us-east1-gcp")
+assert PINECONE_ENVIRONMENT, "PINECONE_ENVIRONMENT environment variable is missing from .env"
+
+# Table config
+PINECONE_TABLE_NAME = os.getenv("TABLE_NAME", "")
+assert PINECONE_TABLE_NAME, "TABLE_NAME environment variable is missing from .env"
+
+# Function to query records from the Pinecone index
+def query_records(index, query, top_k=1000):
+ results = index.query(query, top_k=top_k, include_metadata=True)
+ return [{"name": f"{task.metadata['task']}", "result": f"{task.metadata['result']}"} for task in results.matches]
+
+# Get embedding for the text
+def get_ada_embedding(text):
+ return openai.Embedding.create(input=[text], model="text-embedding-ada-002")["data"][0]["embedding"]
+
+def draw_tasks(stdscr, tasks, scroll_pos, selected):
+ y = 0
+ h, w = stdscr.getmaxyx()
+ for idx, task in enumerate(tasks[scroll_pos:], start=scroll_pos):
+ if y >= h:
+ break
+ task_name = f'{task["name"]}'
+ truncated_str = task_name[:w-1]
+ if idx == selected:
+ stdscr.addstr(y, 0, truncated_str, curses.A_REVERSE)
+ else:
+ stdscr.addstr(y, 0, truncated_str)
+ y += 1
+
+def draw_result(stdscr, task):
+ task_name = f'Task: {task["name"]}'
+ task_result = f'Result: {task["result"]}'
+
+ _, w = stdscr.getmaxyx()
+ task_name_wrapped = textwrap.wrap(task_name, width=w)
+
+ for i, line in enumerate(task_name_wrapped):
+ stdscr.addstr(i, 0, line)
+
+ y, _ = stdscr.getyx()
+ stdscr.addstr(y+1, 0, '------------------')
+ stdscr.addstr(y+2, 0, task_result)
+
+def draw_summary(stdscr, objective, tasks, start, num):
+ stdscr.box()
+ summary_text = f'{len(tasks)} tasks ({start}-{num}) | {objective}'
+ stdscr.addstr(1, 1, summary_text[:stdscr.getmaxyx()[1] - 2])
+
+def main(stdscr):
+ # Configure OpenAI
+ openai.api_key = OPENAI_API_KEY
+
+ # Initialize Pinecone
+ pinecone.init(api_key=PINECONE_API_KEY)
+
+ # Connect to the objective index
+ index = pinecone.Index(PINECONE_TABLE_NAME)
+
+ curses.curs_set(0)
+ stdscr.timeout(1000)
+
+ h, w = stdscr.getmaxyx()
+ left_w = w // 2
+ visible_lines = h - 3
+
+ scroll_pos = 0
+ selected = 0
+
+ # Parse command-line arguments
+ parser = argparse.ArgumentParser(description="Query Pinecone index using a string.")
+ parser.add_argument('objective', nargs='*', metavar='', help='''
+ main objective description. Doesn\'t need to be quoted.
+ if not specified, get objective from environment.
+ ''', default=[os.getenv("OBJECTIVE", "")])
+ args = parser.parse_args()
+
+ # Query records from the index
+ objective = ' '.join(args.objective).strip().replace("\n", " ")
+ retrieved_tasks = query_records(index, get_ada_embedding(objective))
+
+ while True:
+ stdscr.clear()
+ draw_tasks(stdscr.subwin(h-3, left_w, 0, 0), retrieved_tasks, scroll_pos, selected)
+ draw_result(stdscr.subwin(h, w - left_w, 0, left_w), retrieved_tasks[selected])
+ draw_summary(stdscr.subwin(3, left_w, h - 3, 0), objective, retrieved_tasks, scroll_pos+1, scroll_pos+h-3)
+
+ stdscr.refresh()
+ key = stdscr.getch()
+
+ if key == ord('q') or key == 27:
+ break
+ elif key == curses.KEY_UP and selected > 0:
+ selected -= 1
+ if selected < scroll_pos:
+ scroll_pos -= 1
+ elif key == curses.KEY_DOWN and selected < len(retrieved_tasks) - 1:
+ selected += 1
+ if selected - scroll_pos >= visible_lines:
+ scroll_pos += 1
+
+curses.wrapper(main)
\ No newline at end of file
](docs/README-ar.md)
+[
](docs/README-fr.md)
+[
](docs/README-pl.md)
+[
](docs/README-pt-br.md)
+[
](docs/README-ro.md)
+[
](docs/README-ru.md)
+[
](docs/README-si.md)
+[
](docs/README-es.md)
+[
](docs/README-tr.md)
+[
](docs/README-ua.md)
+[
](docs/README-cn.md)
+[
](docs/README-zh-tw.md)
+[
](docs/README-ja.md)
+[
](docs/README-ko.md)
+[
](docs/README-hu.md)
+[
](docs/README-fa.md)
+[
](docs/README-de.md)
+[
](docs/README-in.md)
-> [!CAUTION]
-> This is a framework built by Yohei who has never held a job as a developer. The purpose of this repo is to share ideas and spark discussion and for experienced devs to play with. Not meant for production use. Use with cautioun.
----
+# Objective
-This newest BabyAGI is an experimental framework for a self-building autonomous agent. Earlier efforts to expand BabyAGI have made it clear that the optimal way to build a general autonomous agent is to build the simplest thing that can build itself.
+This Python script is an example of an AI-powered task management system. The system uses OpenAI and vector databases such as Chroma or Weaviate to create, prioritize, and execute tasks. The main idea behind this system is that it creates tasks based on the result of previous tasks and a predefined objective. The script then uses OpenAI's natural language processing (NLP) capabilities to create new tasks based on the objective, and Chroma/Weaviate to store and retrieve task results for context. This is a pared-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023).
-The core is a new function framework (**functionz**) for storing, managing, and executing functions from a database. It offers a graph-based structure for tracking imports, dependent functions, and authentication secrets, with automatic loading and comprehensive logging capabilities. Additionally, it comes with a dashboard for managing functions, running updates, and viewing logs.
+This README will cover the following:
-## Table of Contents
+- [How the script works](#how-it-works)
-- [Quick Start](#quick-start)
-- [Basic Usage](#basic-usage)
-- [Function Metadata](#function-metadata)
-- [Function Loading](#function-loading)
-- [Key Dependencies](#key-dependencies)
-- [Execution Environment](#execution-environment)
- - [Log](#log)
-- [Dashboard](#dashboard)
-- [Pre-loaded Functions](#pre-loaded-functions)
-- [Future/Draft Features](#futuredraft-features)
-- [API Reference](#api-reference)
-- [Contributing](#contributing)
-- [License](#license)
+- [How to use the script](#how-to-use)
-## Quick Start
+- [Supported Models](#supported-models)
-To quickly check out the dashboard and see how it works:
+- [Warning about running the script continuously](#continuous-script-warning)
-1. **Install BabyAGI:** (PIP INSTALL WILL NOT WORK UNTIL WE PUSH TO PYPI, USE GIT CLONE FOR NOW)
+# How It Works
- ```bash
- pip install babyagi
- ```
+The script works by running an infinite loop that does the following steps:
-2. **Import BabyAGI and load the dashboard:**
+1. Pulls the first task from the task list.
+2. Sends the task to the execution agent, which uses OpenAI's API to complete the task based on the context.
+3. Enriches the result and stores it in [Chroma](https://docs.trychroma.com)/[Weaviate](https://weaviate.io/).
+4. Creates new tasks and reprioritizes the task list based on the objective and the result of the previous task.
+
- ```python
- import babyagi
+
- if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
- ```
+The `execution_agent()` function is where the OpenAI API is used. It takes two parameters: the objective and the task. It then sends a prompt to OpenAI's API, which returns the result of the task. The prompt consists of a description of the AI system's task, the objective, and the task itself. The result is then returned as a string.
-3. **Navigate to the dashboard:**
+The `task_creation_agent()` function is where OpenAI's API is used to create new tasks based on the objective and the result of the previous task. The function takes four parameters: the objective, the result of the previous task, the task description, and the current task list. It then sends a prompt to OpenAI's API, which returns a list of new tasks as strings. The function then returns the new tasks as a list of dictionaries, where each dictionary contains the name of the task.
- Open your browser and go to `http://localhost:8080/dashboard` to access the BabyAGI dashboard.
-
-## Basic Usage
+The `prioritization_agent()` function is where OpenAI's API is used to reprioritize the task list. The function takes one parameter, the ID of the current task. It sends a prompt to OpenAI's API, which returns the reprioritized task list as a numbered list.
-Start by importing `babyagi` and registering your functions. Here's how to register two functions, where one depends on the other:
+Finally, the script uses Chroma/Weaviate to store and retrieve task results for context. The script creates a Chroma/Weaviate collection based on the table name specified in the TABLE_NAME variable. Chroma/Weaviate is then used to store the results of the task in the collection, along with the task name and any additional metadata.
-```python
-import babyagi
+# How to Use
-# Register a simple function
-@babyagi.register_function()
-def world():
- return "world"
+To use the script, you will need to follow these steps:
-# Register a function that depends on 'world'
-@babyagi.register_function(dependencies=["world"])
-def hello_world():
- x = world()
- return f"Hello {x}!"
+1. Clone the repository via `git clone https://github.com/yoheinakajima/babyagi.git` and `cd` into the cloned repository.
+2. Install the required packages: `pip install -r requirements.txt`
+3. Copy the .env.example file to .env: `cp .env.example .env`. This is where you will set the following variables.
+4. Set your OpenAI API key in the OPENAI_API_KEY and OPENAI_API_MODEL variables. In order to use with Weaviate you will also need to setup additional variables detailed [here](docs/weaviate.md).
+5. Set the name of the table where the task results will be stored in the TABLE_NAME variable.
+6. (Optional) Set the name of the BabyAGI instance in the BABY_NAME variable.
+7. (Optional) Set the objective of the task management system in the OBJECTIVE variable.
+8. (Optional) Set the first task of the system in the INITIAL_TASK variable.
+9. Run the script: `python babyagi.py`
-# Execute the function
-print(babyagi.hello_world()) # Output: Hello world!
+All optional values above can also be specified on the command line.
-if __name__ == "__main__":
- app = babyagi.create_app('/dashboard')
- app.run(host='0.0.0.0', port=8080)
-```
-
-## Function Metadata
-
-Functions can be registered with metadata to enhance their capabilities and manage their relationships. Here's a more comprehensive example of function metadata, showing logical usage of all fields:
-
-```python
-import babyagi
-
-@babyagi.register_function(
- imports=["math"],
- dependencies=["circle_area"],
- key_dependencies=["openai_api_key"],
- metadata={
- "description": "Calculates the volume of a cylinder using the circle_area function."
- }
-)
-def cylinder_volume(radius, height):
- import math
- area = circle_area(radius)
- return area * height
-```
-
-**Available Metadata Fields:**
-
-- `imports`: List of external libraries the function depends on.
-- `dependencies`: List of other functions this function depends on.
-- `key_dependencies`: List of secret keys required by the function.
-- `metadata["description"]`: A description of what the function does.
-
-## Function Loading
+# Running inside a docker container
-In addition to using `register_function`, you can use `load_function` to load plugins or draft packs of functions. BabyAGI comes with built-in function packs, or you can load your own packs by pointing to the file path.
+As a prerequisite, you will need docker and docker-compose installed. Docker desktop is the simplest option https://www.docker.com/products/docker-desktop/
-You can find available function packs in `babyagi/functionz/packs`.
+To run the system inside a docker container, setup your .env file as per steps above and then run the following:
-**Loading Custom Function Packs:**
-
-```python
-import babyagi
-
-# Load your custom function pack
-babyagi.load_functions("path/to/your/custom_functions.py")
```
-
-This approach makes function building and management easier by organizing related functions into packs.
-
-## Key Dependencies
-
-You can store `key_dependencies` directly from your code or manage them via the dashboard.
-
-**Storing Key Dependencies from Code:**
-
-```python
-import babyagi
-
-# Add a secret key
-babyagi.add_key_wrapper('openai_api_key', 'your_openai_api_key')
+docker-compose up
```
-**Adding Key Dependencies via Dashboard:**
-
-Navigate to the dashboard and use the **add_key_wrapper** feature to securely add your secret keys.
-
-## Execution Environment
-
-BabyAGI automatically loads essential function packs and manages their dependencies, ensuring a seamless execution environment. Additionally, it logs all activities, including the relationships between functions, to provide comprehensive tracking of function executions and dependencies.
-
-### Log
-
-BabyAGI implements a comprehensive logging system to track all function executions and their interactions. The logging mechanism ensures that every function call, including its inputs, outputs, execution time, and any errors, is recorded for monitoring and debugging purposes.
-
-**Key Logging Features:**
-
-- **Execution Tracking:** Logs when a function starts and finishes execution, including the function name, arguments, keyword arguments, and execution time.
-
-- **Error Logging:** Captures and logs any errors that occur during function execution, providing detailed error messages for troubleshooting.
-
-- **Dependency Management:** Automatically resolves and logs dependencies between functions, ensuring that all required functions and libraries are loaded before execution.
-
-- **Trigger Logging:** Logs the execution of triggered functions, detailing which functions were triggered by others and their respective execution outcomes.
-
-- **Comprehensive Records:** Maintains a history of all function executions, enabling users to review past activities, understand function relationships, and analyze performance metrics.
-
-**How Triggers Work:**
-
-Triggers are mechanisms that allow certain functions to be automatically executed in response to specific events or actions within the system. For example, when a function is added or updated, a trigger can initiate the generation of a description for that function.
-
-Triggers enhance the autonomy of BabyAGI by enabling automated workflows and reducing the need for manual intervention. However, it's essential to manage triggers carefully to avoid unintended recursive executions or conflicts between dependent functions.
-
-## Dashboard
-
-The BabyAGI dashboard offers a user-friendly interface for managing functions, monitoring executions, and handling configurations. Key features include:
-
-- **Function Management:** Register, deregister, and update functions directly from the dashboard.
-
-- **Dependency Visualization:** View and manage dependencies between functions to understand their relationships.
-
-- **Secret Key Management:** Add and manage secret keys securely through the dashboard interface.
-
-- **Logging and Monitoring:** Access comprehensive logs of function executions, including inputs, outputs, and execution times.
-
-- **Trigger Management:** Set up triggers to automate function executions based on specific events or conditions.
-
-**Accessing the Dashboard:**
-
-After running your application, navigate to `http://localhost:8080/dashboard` to access the BabyAGI dashboard.
-## Pre-loaded Functions Summary
-
-BabyAGI includes two pre-loaded function packs:
-
-1. **Default Functions (`packs/default_functions.py`):**
- - **Function Execution:** Run, add, update, or retrieve functions and versions.
- - **Key Management:** Add and retrieve secret keys.
- - **Triggers:** Add triggers to execute functions based on others.
- - **Logs:** Retrieve logs with optional filters.
-
-2. **AI Functions (`packs/ai_generator.py`):**
- - **AI Description & Embeddings:** Auto-generate descriptions and embeddings for functions.
- - **Function Selection:** Find or choose similar functions based on prompts.
-
-## Running a Self-Building Agent
-
-BabyAGI includes two experimental self-building agents, showcasing how the framework can help a self-building coding agent leverage existing functions to write new ones.
-
-### 1. `process_user_input` in the `code_writing_functions` pack
-
-This function first determines whether to use an existing function or generate new ones. If new functions are needed, it breaks them down into smaller reusable components and combines them into a final function.
+# Supported Models
-Try this:
+This script works with all OpenAI models, as well as Llama and its variations through Llama.cpp. Default model is **gpt-3.5-turbo**. To use a different model, specify it through LLM_MODEL or use the command line.
-~~~python
-import babyagi
+## Llama
-babyagi.add_key_wrapper('openai_api_key', os.environ['OPENAI_API_KEY'])
-babyagi.load_functions("drafts/code_writing_functions")
+Llama integration requires llama-cpp package. You will also need the Llama model weights.
-babyagi.process_user_input("Grab today's score from ESPN and email it to test@test.com")
-~~~
+- **Under no circumstances share IPFS, magnet links, or any other links to model downloads anywhere in this repository, including in issues, discussions or pull requests. They will be immediately deleted.**
-When you run this, you will see the functions being generated in the shell and new functions will be available in the dashboard once completed.
+Once you have them, set LLAMA_MODEL_PATH to the path of the specific model to use. For convenience, you can link `models` in BabyAGI repo to the folder where you have the Llama model weights. Then run the script with `LLM_MODEL=llama` or `-l` argument.
-### 2. `self_build` in the `self_build` pack
+# Warning
-This function takes a user description and generates X distinct tasks that a user might ask an AI assistant. Each task is processed by `process_user_input`, creating new functions if no existing ones suffice.
+This script is designed to be run continuously as part of a task management system. Running this script continuously can result in high API usage, so please use it responsibly. Additionally, the script requires the OpenAI API to be set up correctly, so make sure you have set up the API before running the script.
-Try this:
+# Contribution
-~~~python
-import babyagi
+Needless to say, BabyAGI is still in its infancy and thus we are still determining its direction and the steps to get there. Currently, a key design goal for BabyAGI is to be _simple_ such that it's easy to understand and build upon. To maintain this simplicity, we kindly request that you adhere to the following guidelines when submitting PRs:
-babyagi.add_key_wrapper('openai_api_key', os.environ['OPENAI_API_KEY'])
-babyagi.load_functions("drafts/code_writing_functions")
-babyagi.load_functions("drafts/self_build")
+- Focus on small, modular modifications rather than extensive refactoring.
+- When introducing new features, provide a detailed description of the specific use case you are addressing.
-babyagi.self_build("A sales person at an enterprise SaaS company.", 3)
-~~~
+A note from @yoheinakajima (Apr 5th, 2023):
-This will generate 3 distinct tasks a salesperson might ask an AI assistant and create functions to handle those.
+> I know there are a growing number of PRs, appreciate your patience - as I am both new to GitHub/OpenSource, and did not plan my time availability accordingly this week. Re:direction, I've been torn on keeping it simple vs expanding - currently leaning towards keeping a core Baby AGI simple, and using this as a platform to support and promote different approaches to expanding this (eg. BabyAGIxLangchain as one direction). I believe there are various opinionated approaches that are worth exploring, and I see value in having a central place to compare and discuss. More updates coming shortly.
-*The functions will be generated and stored in the dashboard, but note that the generated code is minimal and may need improvement.
+I am new to GitHub and open source, so please be patient as I learn to manage this project properly. I run a VC firm by day, so I will generally be checking PRs and issues at night after I get my kids down - which may not be every night. Open to the idea of bringing in support, will be updating this section soon (expectations, visions, etc). Talking to lots of people and learning - hang tight for updates!
-
+# BabyAGI Activity Report
+To help the BabyAGI community stay informed about the project's progress, Blueprint AI has developed a Github activity summarizer for BabyAGI. This concise report displays a summary of all contributions to the BabyAGI repository over the past 7 days (continuously updated), making it easy for you to keep track of the latest developments.
+To view the BabyAGI 7-day activity report, go here: [https://app.blueprint.ai/github/yoheinakajima/babyagi](https://app.blueprint.ai/github/yoheinakajima/babyagi)
-**Warning:** These draft features are experimental concepts and may not function as intended. They require significant improvements and should be used with caution.
+[
](https://app.blueprint.ai/github/yoheinakajima/babyagi)
-## Contributing
+# Inspired projects
-Contributions are greatly appreciatedly, but candidly I have not been great at managing PRs. Please be patient as things will move slow while I am working on this alone (on nights and weekends). I may start by building a small core crew before collaborating with a larger group.
+In the short time since it was release, BabyAGI inspired many projects. You can see them all [here](docs/inspired-projects.md).
-If you are a dev, investor, friend of open-source and interesting supporting AI work I do, please fill [this form]([https://](https://forms.gle/UZLyT75HQULr8XNUA)) (I have a few fun initiatives coming up!)
+# Backstory
-## License
+BabyAGI is a pared-down version of the original [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) (Mar 28, 2023) shared on Twitter. This version is down to 140 lines: 13 comments, 22 blanks, and 105 code. The name of the repo came up in the reaction to the original autonomous agent - the author does not mean to imply that this is AGI.
-BabyAGI is released under the MIT License. See the [LICENSE](LICENSE) file for more details.
+Made with love by [@yoheinakajima](https://twitter.com/yoheinakajima), who happens to be a VC (would love to see what you're building!)
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 00000000..8daa2467
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1,14 @@
+title: BabyAGI
+email:
+description: >-
+ BabyAGI is an AI-powered task management system that uses OpenAI and Pinecone APIs to create, prioritize, and execute tasks.
+baseurl: ""
+url: "https://babyagi.org"
+logo: docs/babyagi.png
+twitter_username: babyagi_
+github_username: yoheinakajima
+show_downloads: false
+remote_theme: pages-themes/minimal@v0.2.0
+include: [docs]
+plugins:
+- jekyll-remote-theme
diff --git a/babyagi.py b/babyagi.py
new file mode 100755
index 00000000..2650e412
--- /dev/null
+++ b/babyagi.py
@@ -0,0 +1,609 @@
+#!/usr/bin/env python3
+from dotenv import load_dotenv
+
+# Load default environment variables (.env)
+load_dotenv()
+
+import os
+import time
+import logging
+from collections import deque
+from typing import Dict, List
+import importlib
+import openai
+import chromadb
+import tiktoken as tiktoken
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
+import re
+
+# default opt out of chromadb telemetry.
+from chromadb.config import Settings
+
+client = chromadb.Client(Settings(anonymized_telemetry=False))
+
+# Engine configuration
+
+# Model: GPT, LLAMA, HUMAN, etc.
+LLM_MODEL = os.getenv("LLM_MODEL", os.getenv("OPENAI_API_MODEL", "gpt-3.5-turbo")).lower()
+
+# API Keys
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+if not (LLM_MODEL.startswith("llama") or LLM_MODEL.startswith("human")):
+ assert OPENAI_API_KEY, "\033[91m\033[1m" + "OPENAI_API_KEY environment variable is missing from .env" + "\033[0m\033[0m"
+
+# Table config
+RESULTS_STORE_NAME = os.getenv("RESULTS_STORE_NAME", os.getenv("TABLE_NAME", ""))
+assert RESULTS_STORE_NAME, "\033[91m\033[1m" + "RESULTS_STORE_NAME environment variable is missing from .env" + "\033[0m\033[0m"
+
+# Run configuration
+INSTANCE_NAME = os.getenv("INSTANCE_NAME", os.getenv("BABY_NAME", "BabyAGI"))
+COOPERATIVE_MODE = "none"
+JOIN_EXISTING_OBJECTIVE = False
+
+# Goal configuration
+OBJECTIVE = os.getenv("OBJECTIVE", "")
+INITIAL_TASK = os.getenv("INITIAL_TASK", os.getenv("FIRST_TASK", ""))
+
+# Model configuration
+OPENAI_TEMPERATURE = float(os.getenv("OPENAI_TEMPERATURE", 0.0))
+
+
+# Extensions support begin
+
+def can_import(module_name):
+ try:
+ importlib.import_module(module_name)
+ return True
+ except ImportError:
+ return False
+
+
+DOTENV_EXTENSIONS = os.getenv("DOTENV_EXTENSIONS", "").split(" ")
+
+# Command line arguments extension
+# Can override any of the above environment variables
+ENABLE_COMMAND_LINE_ARGS = (
+ os.getenv("ENABLE_COMMAND_LINE_ARGS", "false").lower() == "true"
+)
+if ENABLE_COMMAND_LINE_ARGS:
+ if can_import("extensions.argparseext"):
+ from extensions.argparseext import parse_arguments
+
+ OBJECTIVE, INITIAL_TASK, LLM_MODEL, DOTENV_EXTENSIONS, INSTANCE_NAME, COOPERATIVE_MODE, JOIN_EXISTING_OBJECTIVE = parse_arguments()
+
+# Human mode extension
+# Gives human input to babyagi
+if LLM_MODEL.startswith("human"):
+ if can_import("extensions.human_mode"):
+ from extensions.human_mode import user_input_await
+
+# Load additional environment variables for enabled extensions
+# TODO: This might override the following command line arguments as well:
+# OBJECTIVE, INITIAL_TASK, LLM_MODEL, INSTANCE_NAME, COOPERATIVE_MODE, JOIN_EXISTING_OBJECTIVE
+if DOTENV_EXTENSIONS:
+ if can_import("extensions.dotenvext"):
+ from extensions.dotenvext import load_dotenv_extensions
+
+ load_dotenv_extensions(DOTENV_EXTENSIONS)
+
+# TODO: There's still work to be done here to enable people to get
+# defaults from dotenv extensions, but also provide command line
+# arguments to override them
+
+# Extensions support end
+
+print("\033[95m\033[1m" + "\n*****CONFIGURATION*****\n" + "\033[0m\033[0m")
+print(f"Name : {INSTANCE_NAME}")
+print(f"Mode : {'alone' if COOPERATIVE_MODE in ['n', 'none'] else 'local' if COOPERATIVE_MODE in ['l', 'local'] else 'distributed' if COOPERATIVE_MODE in ['d', 'distributed'] else 'undefined'}")
+print(f"LLM : {LLM_MODEL}")
+
+
+# Check if we know what we are doing
+assert OBJECTIVE, "\033[91m\033[1m" + "OBJECTIVE environment variable is missing from .env" + "\033[0m\033[0m"
+assert INITIAL_TASK, "\033[91m\033[1m" + "INITIAL_TASK environment variable is missing from .env" + "\033[0m\033[0m"
+
+LLAMA_MODEL_PATH = os.getenv("LLAMA_MODEL_PATH", "models/llama-13B/ggml-model.bin")
+if LLM_MODEL.startswith("llama"):
+ if can_import("llama_cpp"):
+ from llama_cpp import Llama
+
+ print(f"LLAMA : {LLAMA_MODEL_PATH}" + "\n")
+ assert os.path.exists(LLAMA_MODEL_PATH), "\033[91m\033[1m" + f"Model can't be found." + "\033[0m\033[0m"
+
+ CTX_MAX = 1024
+ LLAMA_THREADS_NUM = int(os.getenv("LLAMA_THREADS_NUM", 8))
+
+ print('Initialize model for evaluation')
+ llm = Llama(
+ model_path=LLAMA_MODEL_PATH,
+ n_ctx=CTX_MAX,
+ n_threads=LLAMA_THREADS_NUM,
+ n_batch=512,
+ use_mlock=False,
+ )
+
+ print('\nInitialize model for embedding')
+ llm_embed = Llama(
+ model_path=LLAMA_MODEL_PATH,
+ n_ctx=CTX_MAX,
+ n_threads=LLAMA_THREADS_NUM,
+ n_batch=512,
+ embedding=True,
+ use_mlock=False,
+ )
+
+ print(
+ "\033[91m\033[1m"
+ + "\n*****USING LLAMA.CPP. POTENTIALLY SLOW.*****"
+ + "\033[0m\033[0m"
+ )
+ else:
+ print(
+ "\033[91m\033[1m"
+ + "\nLlama LLM requires package llama-cpp. Falling back to GPT-3.5-turbo."
+ + "\033[0m\033[0m"
+ )
+ LLM_MODEL = "gpt-3.5-turbo"
+
+if LLM_MODEL.startswith("gpt-4"):
+ print(
+ "\033[91m\033[1m"
+ + "\n*****USING GPT-4. POTENTIALLY EXPENSIVE. MONITOR YOUR COSTS*****"
+ + "\033[0m\033[0m"
+ )
+
+if LLM_MODEL.startswith("human"):
+ print(
+ "\033[91m\033[1m"
+ + "\n*****USING HUMAN INPUT*****"
+ + "\033[0m\033[0m"
+ )
+
+print("\033[94m\033[1m" + "\n*****OBJECTIVE*****\n" + "\033[0m\033[0m")
+print(f"{OBJECTIVE}")
+
+if not JOIN_EXISTING_OBJECTIVE:
+ print("\033[93m\033[1m" + "\nInitial task:" + "\033[0m\033[0m" + f" {INITIAL_TASK}")
+else:
+ print("\033[93m\033[1m" + f"\nJoining to help the objective" + "\033[0m\033[0m")
+
+# Configure OpenAI
+openai.api_key = OPENAI_API_KEY
+
+
+# Llama embedding function
+class LlamaEmbeddingFunction(EmbeddingFunction):
+ def __init__(self):
+ return
+
+
+ def __call__(self, texts: Documents) -> Embeddings:
+ embeddings = []
+ for t in texts:
+ e = llm_embed.embed(t)
+ embeddings.append(e)
+ return embeddings
+
+
+# Results storage using local ChromaDB
+class DefaultResultsStorage:
+ def __init__(self):
+ logging.getLogger('chromadb').setLevel(logging.ERROR)
+ # Create Chroma collection
+ chroma_persist_dir = "chroma"
+ chroma_client = chromadb.PersistentClient(
+ settings=chromadb.config.Settings(
+ persist_directory=chroma_persist_dir,
+ )
+ )
+
+ metric = "cosine"
+ if LLM_MODEL.startswith("llama"):
+ embedding_function = LlamaEmbeddingFunction()
+ else:
+ embedding_function = OpenAIEmbeddingFunction(api_key=OPENAI_API_KEY)
+ self.collection = chroma_client.get_or_create_collection(
+ name=RESULTS_STORE_NAME,
+ metadata={"hnsw:space": metric},
+ embedding_function=embedding_function,
+ )
+
+ def add(self, task: Dict, result: str, result_id: str):
+
+ # Break the function if LLM_MODEL starts with "human" (case-insensitive)
+ if LLM_MODEL.startswith("human"):
+ return
+ # Continue with the rest of the function
+
+ embeddings = llm_embed.embed(result) if LLM_MODEL.startswith("llama") else None
+ if (
+ len(self.collection.get(ids=[result_id], include=[])["ids"]) > 0
+ ): # Check if the result already exists
+ self.collection.update(
+ ids=result_id,
+ embeddings=embeddings,
+ documents=result,
+ metadatas={"task": task["task_name"], "result": result},
+ )
+ else:
+ self.collection.add(
+ ids=result_id,
+ embeddings=embeddings,
+ documents=result,
+ metadatas={"task": task["task_name"], "result": result},
+ )
+
+ def query(self, query: str, top_results_num: int) -> List[dict]:
+ count: int = self.collection.count()
+ if count == 0:
+ return []
+ results = self.collection.query(
+ query_texts=query,
+ n_results=min(top_results_num, count),
+ include=["metadatas"]
+ )
+ return [item["task"] for item in results["metadatas"][0]]
+
+
+# Initialize results storage
+def try_weaviate():
+ WEAVIATE_URL = os.getenv("WEAVIATE_URL", "")
+ WEAVIATE_USE_EMBEDDED = os.getenv("WEAVIATE_USE_EMBEDDED", "False").lower() == "true"
+ if (WEAVIATE_URL or WEAVIATE_USE_EMBEDDED) and can_import("extensions.weaviate_storage"):
+ WEAVIATE_API_KEY = os.getenv("WEAVIATE_API_KEY", "")
+ from extensions.weaviate_storage import WeaviateResultsStorage
+ print("\nUsing results storage: " + "\033[93m\033[1m" + "Weaviate" + "\033[0m\033[0m")
+ return WeaviateResultsStorage(OPENAI_API_KEY, WEAVIATE_URL, WEAVIATE_API_KEY, WEAVIATE_USE_EMBEDDED, LLM_MODEL, LLAMA_MODEL_PATH, RESULTS_STORE_NAME, OBJECTIVE)
+ return None
+
+def try_pinecone():
+ PINECONE_API_KEY = os.getenv("PINECONE_API_KEY", "")
+ if PINECONE_API_KEY and can_import("extensions.pinecone_storage"):
+ PINECONE_ENVIRONMENT = os.getenv("PINECONE_ENVIRONMENT", "")
+ assert (
+ PINECONE_ENVIRONMENT
+ ), "\033[91m\033[1m" + "PINECONE_ENVIRONMENT environment variable is missing from .env" + "\033[0m\033[0m"
+ from extensions.pinecone_storage import PineconeResultsStorage
+ print("\nUsing results storage: " + "\033[93m\033[1m" + "Pinecone" + "\033[0m\033[0m")
+ return PineconeResultsStorage(OPENAI_API_KEY, PINECONE_API_KEY, PINECONE_ENVIRONMENT, LLM_MODEL, LLAMA_MODEL_PATH, RESULTS_STORE_NAME, OBJECTIVE)
+ return None
+
+def use_chroma():
+ print("\nUsing results storage: " + "\033[93m\033[1m" + "Chroma (Default)" + "\033[0m\033[0m")
+ return DefaultResultsStorage()
+
+results_storage = try_weaviate() or try_pinecone() or use_chroma()
+
+# Task storage supporting only a single instance of BabyAGI
+class SingleTaskListStorage:
+ def __init__(self):
+ self.tasks = deque([])
+ self.task_id_counter = 0
+
+ def append(self, task: Dict):
+ self.tasks.append(task)
+
+ def replace(self, tasks: List[Dict]):
+ self.tasks = deque(tasks)
+
+ def popleft(self):
+ return self.tasks.popleft()
+
+ def is_empty(self):
+ return False if self.tasks else True
+
+ def next_task_id(self):
+ self.task_id_counter += 1
+ return self.task_id_counter
+
+ def get_task_names(self):
+ return [t["task_name"] for t in self.tasks]
+
+
+# Initialize tasks storage
+tasks_storage = SingleTaskListStorage()
+if COOPERATIVE_MODE in ['l', 'local']:
+ if can_import("extensions.ray_tasks"):
+ import sys
+ from pathlib import Path
+
+ sys.path.append(str(Path(__file__).resolve().parent))
+ from extensions.ray_tasks import CooperativeTaskListStorage
+
+ tasks_storage = CooperativeTaskListStorage(OBJECTIVE)
+ print("\nReplacing tasks storage: " + "\033[93m\033[1m" + "Ray" + "\033[0m\033[0m")
+elif COOPERATIVE_MODE in ['d', 'distributed']:
+ pass
+
+
+def limit_tokens_from_string(string: str, model: str, limit: int) -> str:
+ """Limits the string to a number of tokens (estimated)."""
+
+ try:
+ encoding = tiktoken.encoding_for_model(model)
+ except:
+ encoding = tiktoken.encoding_for_model('gpt2') # Fallback for others.
+
+ encoded = encoding.encode(string)
+
+ return encoding.decode(encoded[:limit])
+
+
+def openai_call(
+ prompt: str,
+ model: str = LLM_MODEL,
+ temperature: float = OPENAI_TEMPERATURE,
+ max_tokens: int = 100,
+):
+ while True:
+ try:
+ if model.lower().startswith("llama"):
+ result = llm(prompt[:CTX_MAX],
+ stop=["### Human"],
+ echo=False,
+ temperature=0.2,
+ top_k=40,
+ top_p=0.95,
+ repeat_penalty=1.05,
+ max_tokens=200)
+ # print('\n*****RESULT JSON DUMP*****\n')
+ # print(json.dumps(result))
+ # print('\n')
+ return result['choices'][0]['text'].strip()
+ elif model.lower().startswith("human"):
+ return user_input_await(prompt)
+ elif not model.lower().startswith("gpt-"):
+ # Use completion API
+ response = openai.Completion.create(
+ engine=model,
+ prompt=prompt,
+ temperature=temperature,
+ max_tokens=max_tokens,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0,
+ )
+ return response.choices[0].text.strip()
+ else:
+ # Use 4000 instead of the real limit (4097) to give a bit of wiggle room for the encoding of roles.
+ # TODO: different limits for different models.
+
+ trimmed_prompt = limit_tokens_from_string(prompt, model, 4000 - max_tokens)
+
+ # Use chat completion API
+ messages = [{"role": "system", "content": trimmed_prompt}]
+ response = openai.ChatCompletion.create(
+ model=model,
+ messages=messages,
+ temperature=temperature,
+ max_tokens=max_tokens,
+ n=1,
+ stop=None,
+ )
+ return response.choices[0].message.content.strip()
+ except openai.error.RateLimitError:
+ print(
+ " *** The OpenAI API rate limit has been exceeded. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.Timeout:
+ print(
+ " *** OpenAI API timeout occurred. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.APIError:
+ print(
+ " *** OpenAI API error occurred. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.APIConnectionError:
+ print(
+ " *** OpenAI API connection error occurred. Check your network settings, proxy configuration, SSL certificates, or firewall rules. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.InvalidRequestError:
+ print(
+ " *** OpenAI API invalid request. Check the documentation for the specific API method you are calling and make sure you are sending valid and complete parameters. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ except openai.error.ServiceUnavailableError:
+ print(
+ " *** OpenAI API service unavailable. Waiting 10 seconds and trying again. ***"
+ )
+ time.sleep(10) # Wait 10 seconds and try again
+ else:
+ break
+
+
+def task_creation_agent(
+ objective: str, result: Dict, task_description: str, task_list: List[str]
+):
+ prompt = f"""
+You are to use the result from an execution agent to create new tasks with the following objective: {objective}.
+The last completed task has the result: \n{result["data"]}
+This result was based on this task description: {task_description}.\n"""
+
+ if task_list:
+ prompt += f"These are incomplete tasks: {', '.join(task_list)}\n"
+ prompt += "Based on the result, return a list of tasks to be completed in order to meet the objective. "
+ if task_list:
+ prompt += "These new tasks must not overlap with incomplete tasks. "
+
+ prompt += """
+Return one task per line in your response. The result must be a numbered list in the format:
+
+#. First task
+#. Second task
+
+The number of each entry must be followed by a period. If your list is empty, write "There are no tasks to add at this time."
+Unless your list is empty, do not include any headers before your numbered list or follow your numbered list with any other output."""
+
+ print(f'\n*****TASK CREATION AGENT PROMPT****\n{prompt}\n')
+ response = openai_call(prompt, max_tokens=2000)
+ print(f'\n****TASK CREATION AGENT RESPONSE****\n{response}\n')
+ new_tasks = response.split('\n')
+ new_tasks_list = []
+ for task_string in new_tasks:
+ task_parts = task_string.strip().split(".", 1)
+ if len(task_parts) == 2:
+ task_id = ''.join(s for s in task_parts[0] if s.isnumeric())
+ task_name = re.sub(r'[^\w\s_]+', '', task_parts[1]).strip()
+ if task_name.strip() and task_id.isnumeric():
+ new_tasks_list.append(task_name)
+ # print('New task created: ' + task_name)
+
+ out = [{"task_name": task_name} for task_name in new_tasks_list]
+ return out
+
+
+def prioritization_agent():
+ task_names = tasks_storage.get_task_names()
+ bullet_string = '\n'
+
+ prompt = f"""
+You are tasked with prioritizing the following tasks: {bullet_string + bullet_string.join(task_names)}
+Consider the ultimate objective of your team: {OBJECTIVE}.
+Tasks should be sorted from highest to lowest priority, where higher-priority tasks are those that act as pre-requisites or are more essential for meeting the objective.
+Do not remove any tasks. Return the ranked tasks as a numbered list in the format:
+
+#. First task
+#. Second task
+
+The entries must be consecutively numbered, starting with 1. The number of each entry must be followed by a period.
+Do not include any headers before your ranked list or follow your list with any other output."""
+
+ print(f'\n****TASK PRIORITIZATION AGENT PROMPT****\n{prompt}\n')
+ response = openai_call(prompt, max_tokens=2000)
+ print(f'\n****TASK PRIORITIZATION AGENT RESPONSE****\n{response}\n')
+ if not response:
+ print('Received empty response from priotritization agent. Keeping task list unchanged.')
+ return
+ new_tasks = response.split("\n") if "\n" in response else [response]
+ new_tasks_list = []
+ for task_string in new_tasks:
+ task_parts = task_string.strip().split(".", 1)
+ if len(task_parts) == 2:
+ task_id = ''.join(s for s in task_parts[0] if s.isnumeric())
+ task_name = re.sub(r'[^\w\s_]+', '', task_parts[1]).strip()
+ if task_name.strip():
+ new_tasks_list.append({"task_id": task_id, "task_name": task_name})
+
+ return new_tasks_list
+
+
+# Execute a task based on the objective and five previous tasks
+def execution_agent(objective: str, task: str) -> str:
+ """
+ Executes a task based on the given objective and previous context.
+
+ Args:
+ objective (str): The objective or goal for the AI to perform the task.
+ task (str): The task to be executed by the AI.
+
+ Returns:
+ str: The response generated by the AI for the given task.
+
+ """
+
+ context = context_agent(query=objective, top_results_num=5)
+ # print("\n****RELEVANT CONTEXT****\n")
+ # print(context)
+ # print('')
+ prompt = f'Perform one task based on the following objective: {objective}.\n'
+ if context:
+ prompt += 'Take into account these previously completed tasks:' + '\n'.join(context)
+ prompt += f'\nYour task: {task}\nResponse:'
+ return openai_call(prompt, max_tokens=2000)
+
+
+# Get the top n completed tasks for the objective
+def context_agent(query: str, top_results_num: int):
+ """
+ Retrieves context for a given query from an index of tasks.
+
+ Args:
+ query (str): The query or objective for retrieving context.
+ top_results_num (int): The number of top results to retrieve.
+
+ Returns:
+ list: A list of tasks as context for the given query, sorted by relevance.
+
+ """
+ results = results_storage.query(query=query, top_results_num=top_results_num)
+ # print("****RESULTS****")
+ # print(results)
+ return results
+
+
+# Add the initial task if starting new objective
+if not JOIN_EXISTING_OBJECTIVE:
+ initial_task = {
+ "task_id": tasks_storage.next_task_id(),
+ "task_name": INITIAL_TASK
+ }
+ tasks_storage.append(initial_task)
+
+
+def main():
+ loop = True
+ while loop:
+ # As long as there are tasks in the storage...
+ if not tasks_storage.is_empty():
+ # Print the task list
+ print("\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m\033[0m")
+ for t in tasks_storage.get_task_names():
+ print(" • " + str(t))
+
+ # Step 1: Pull the first incomplete task
+ task = tasks_storage.popleft()
+ print("\033[92m\033[1m" + "\n*****NEXT TASK*****\n" + "\033[0m\033[0m")
+ print(str(task["task_name"]))
+
+ # Send to execution function to complete the task based on the context
+ result = execution_agent(OBJECTIVE, str(task["task_name"]))
+ print("\033[93m\033[1m" + "\n*****TASK RESULT*****\n" + "\033[0m\033[0m")
+ print(result)
+
+ # Step 2: Enrich result and store in the results storage
+ # This is where you should enrich the result if needed
+ enriched_result = {
+ "data": result
+ }
+ # extract the actual result from the dictionary
+ # since we don't do enrichment currently
+ # vector = enriched_result["data"]
+
+ result_id = f"result_{task['task_id']}"
+
+ results_storage.add(task, result, result_id)
+
+ # Step 3: Create new tasks and re-prioritize task list
+ # only the main instance in cooperative mode does that
+ new_tasks = task_creation_agent(
+ OBJECTIVE,
+ enriched_result,
+ task["task_name"],
+ tasks_storage.get_task_names(),
+ )
+
+ print('Adding new tasks to task_storage')
+ for new_task in new_tasks:
+ new_task.update({"task_id": tasks_storage.next_task_id()})
+ print(str(new_task))
+ tasks_storage.append(new_task)
+
+ if not JOIN_EXISTING_OBJECTIVE:
+ prioritized_tasks = prioritization_agent()
+ if prioritized_tasks:
+ tasks_storage.replace(prioritized_tasks)
+
+ # Sleep a bit before checking the task list again
+ time.sleep(5)
+ else:
+ print('Done.')
+ loop = False
+
+
+if __name__ == "__main__":
+ main()
diff --git a/babyagi/__init__.py b/babyagi/__init__.py
deleted file mode 100644
index 84cfbc99..00000000
--- a/babyagi/__init__.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# babyagi/__init__.py
-
-from flask import Flask, g
-from .functionz.core.framework import Functionz
-from .dashboard import create_dashboard
-from .api import create_api_blueprint
-import os
-import importlib.util
-import traceback
-import sys
-
-# Singleton instance of the functionz framework
-_func_instance = Functionz()
-
-
-def get_func_instance():
- return _func_instance
-
-def create_app(dashboard_route='/dashboard'):
- app = Flask(__name__)
-
- # Remove leading slash if present to avoid double slashes
- if dashboard_route.startswith('/'):
- dashboard_route = dashboard_route[1:]
-
- # Create and register the dashboard blueprint with dashboard_route
- dashboard_blueprint = create_dashboard(_func_instance, dashboard_route)
-
- # Create and register the API blueprint
- api_blueprint = create_api_blueprint()
-
- # Register the blueprints
- app.register_blueprint(dashboard_blueprint, url_prefix=f'/{dashboard_route}')
- app.register_blueprint(api_blueprint) # Mounted at '/api' as defined in the blueprint
-
- # Store the dashboard route for use in templates
- app.config['DASHBOARD_ROUTE'] = dashboard_route
-
- # Ensure the Functionz instance is accessible in the request context
- @app.before_request
- def set_functionz():
- g.functionz = _func_instance
- g.dashboard_route = dashboard_route # Optional, if needed globally
-
- return app
-
-# Function to register functions using the babyagi framework
-def register_function(*args, **kwargs):
- def wrapper(func):
- try:
- _func_instance.register_function(*args, **kwargs)(func)
- setattr(sys.modules[__name__], func.__name__, func)
- #print(f"Function '{func.__name__}' registered successfully.")
- except Exception as e:
- print(f"Error registering function '{func.__name__}': {e}")
- traceback.print_exc()
- return func
- return wrapper
-
-# Function to load additional function packs
-def load_functions(pack_name_or_path):
- #print(f"Attempting to load function pack: {pack_name_or_path}")
- if os.path.exists(pack_name_or_path):
- try:
- spec = importlib.util.spec_from_file_location("custom_pack", pack_name_or_path)
- module = importlib.util.module_from_spec(spec)
- spec.loader.exec_module(module)
- #print(f"Custom pack loaded from {pack_name_or_path}")
- except Exception as e:
- #print(f"Failed to load custom pack from path '{pack_name_or_path}': {e}")
- traceback.print_exc()
- else:
- try:
- print(f"Assuming '{pack_name_or_path}' is an internal pack...")
- _func_instance.load_function_pack(pack_name_or_path)
- print(f"Internal pack '{pack_name_or_path}' loaded successfully.")
- except Exception as e:
- print(f"Failed to load internal pack '{pack_name_or_path}': {e}")
- traceback.print_exc()
-
-
-def use_blueprints(app, dashboard_route='/dashboard'):
- """
- Registers the babyagi blueprints with the provided Flask app.
-
- Args:
- app (Flask): The Flask application instance.
- dashboard_route (str): The route prefix for the dashboard.
- """
- # Remove leading slash if present
- if dashboard_route.startswith('/'):
- dashboard_route = dashboard_route[1:]
-
- # Create blueprints
- dashboard_blueprint = create_dashboard(_func_instance, dashboard_route)
- api_blueprint = create_api_blueprint()
-
- # Register blueprints
- app.register_blueprint(dashboard_blueprint, url_prefix=f'/{dashboard_route}')
- app.register_blueprint(api_blueprint) # Mounted at '/api' as defined in the blueprint
-
- # Store the dashboard route for use in templates
- app.config['DASHBOARD_ROUTE'] = dashboard_route
-
- # Ensure the Functionz instance is accessible in the request context
- @app.before_request
- def set_functionz():
- g.functionz = _func_instance
- g.dashboard_route = dashboard_route # Optional, if needed globally
-
-
-def __getattr__(name):
- """
- Dynamic attribute access for the babyagi module.
- If a function with the given name exists in the database,
- return a callable that executes the function via the executor.
- """
- try:
- if _func_instance.get_function(name):
- # Return a callable that executes the function via the executor
- return lambda *args, **kwargs: _func_instance.executor.execute(name, *args, **kwargs)
- except Exception as e:
- pass
- raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-# Auto-load default function packs when babyagi is imported
-try:
- print("Attempting to load default function packs...")
- # Uncomment if needed
- _func_instance.load_function_pack('default/default_functions')
- _func_instance.load_function_pack('default/ai_functions')
- _func_instance.load_function_pack('default/os')
- _func_instance.load_function_pack('default/function_calling_chat')
-except Exception as e:
- print(f"Error loading default function packs: {e}")
- traceback.print_exc()
-
-print("babyagi/__init__.py loaded")
diff --git a/babyagi/api/__init__.py b/babyagi/api/__init__.py
deleted file mode 100644
index 2ae48f35..00000000
--- a/babyagi/api/__init__.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# babyagi/api/__init__.py
-
-from flask import Blueprint, jsonify, request, g
-from datetime import datetime
-from io import StringIO
-import logging
-import os
-import sys
-import importlib.util
-
-logger = logging.getLogger(__name__)
-
-def create_api_blueprint():
- api = Blueprint('api', __name__, url_prefix='/api')
-
- # Removed the before_request function since g.functionz is set in the main app
-
- @api.route('/functions')
- def get_functions():
- logger.debug("Accessing /api/functions route.")
- try:
- functions = g.functionz.get_all_functions()
- logger.debug(f"Retrieved {len(functions)} functions.")
- return jsonify(functions)
- except Exception as e:
- logger.error(f"Error in get_functions: {str(e)}", exc_info=True)
- return jsonify({"error": str(e)}), 500
-
- @api.route('/function/
+})
'
+ print(f"html_code: {html_code}")
+
+ return html_code
diff --git a/classic/babyfoxagi/skills/play_music.py b/classic/babyfoxagi/skills/play_music.py
new file mode 100644
index 00000000..e64d75bd
--- /dev/null
+++ b/classic/babyfoxagi/skills/play_music.py
@@ -0,0 +1,102 @@
+from skills.skill import Skill
+import openai
+import requests
+import os
+import json
+from urllib.parse import urlparse
+
+class PlayMusic(Skill):
+ name = 'play_music'
+ description = "A skill that uses the Deezer API to search for music and play it with an html player."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def download_and_save_image(self, url, folder_path="public/static/images"):
+ if not os.path.exists(folder_path):
+ os.makedirs(folder_path)
+
+ response = requests.get(url)
+
+ # Extract file name from URL
+ parsed_url = urlparse(url)
+ file_name = os.path.basename(parsed_url.path)
+
+ # Save image to folder
+ file_path = os.path.join(folder_path, file_name)
+ with open(file_path, 'wb') as f:
+ f.write(response.content)
+
+ return file_path
+
+ def generate_prompt(self, objective):
+ prompt_generation_messages = [
+ {"role": "system", "content": "You are a helpful assistant specialized in generating a query for Deezer's music API which is a query and search type. Search types are artist, album name, genre, and track name. Both query and search type should have single quotes, and separated by a comma"},
+ {"role": "user", "content": "Play some Eminem"},
+ {"role": "assistant", "content": "'Eminem','artist'"},
+ {"role": "user", "content": "Play tropical house."},
+ {"role": "assistant", "content": "'tropical house','genre'"},
+ {"role": "user", "content": "Play 99 problems"},
+ {"role": "assistant", "content": "'99 problems','track'"},
+ {"role": "user", "content": "Play abbey road"},
+ {"role": "assistant", "content": "'abbey road','album'"},
+ {"role": "user", "content": objective}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=prompt_generation_messages
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+ def deezer_search(self, query, search_type):
+ base_url = "https://api.deezer.com/search"
+
+ params = {"q": f"{search_type}:'{query}'"}
+
+ response = requests.get(base_url, params=params)
+
+ if response.status_code != 200:
+ print("Failed to get data:", response.status_code)
+ return None
+
+ results = json.loads(response.text)
+
+ if not results['data']:
+ print("No results found")
+ return None
+
+ first_result = results['data'][0]
+
+ if search_type == "artist":
+ artist_id = first_result['artist']['id']
+ return f''
+ elif search_type == "album":
+ album_id = first_result['album']['id']
+ return f''
+ elif search_type == "track":
+ track_id = first_result['id']
+ return f''
+ elif search_type == "genre":
+ genre_id = first_result['id']
+ return f''
+ else:
+ print("Unsupported search type")
+ return None
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+ print(f"Objective: {objective}")
+
+ generated_prompt = self.generate_prompt(objective)
+ print(f"generated_prompt: {generated_prompt}")
+
+ query, search_type = [x.strip().strip("'") for x in generated_prompt.split(",")]
+
+ response = self.deezer_search(query, search_type) # Modified this line
+
+ return response
diff --git a/classic/babyfoxagi/skills/pretty_me.py b/classic/babyfoxagi/skills/pretty_me.py
new file mode 100644
index 00000000..cc10b637
--- /dev/null
+++ b/classic/babyfoxagi/skills/pretty_me.py
@@ -0,0 +1,101 @@
+import openai
+import logging
+from skills.skill import Skill
+import os
+
+# A little sloppy and experimental, but it's fun. Here's a demo: https://twitter.com/yoheinakajima/status/1699689836746358866
+
+class PrettyMe(Skill):
+ name = 'pretty_me'
+ description = "A tool to update the current website UI by generating JavaScript that will execute upon load to change the front-end interface of the website it's on. The code response will be directly wrapped in a window.onload function and executed on the front-end. Use for any requests related to updating the UI (background, theme, etc.)"
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ try:
+ if not self.valid:
+ return "API keys not configured properly."
+
+ # Read the contents of your CSS and HTML files
+ css_path = os.path.join("public", "static", "style.css")
+ html_path = os.path.join("templates", "index.html")
+
+ with open(css_path, 'r') as css_file, open(html_path, 'r') as html_file:
+ css_content = css_file.read()
+ html_content = html_file.read()
+
+ # Prepare the prompt with CSS and HTML content
+ task_prompt = f"Generate JavaScript code to execute based on the following user input: {objective} {params}\nCSS Content: {css_content}\nHTML Content: {html_content}\nInstructions: only provide Javascript code that would go between the script tags, but do not provide the script tags.\n### Code:"
+ example_input2 = "make me nature themed."
+
+ example_output2 = '''
+ // Remove body background image and adjust body background color
+ document.body.style.backgroundImage = "none";
+ document.body.style.backgroundColor = "#4CAF50"; // Green color
+
+ // Adjust chat box background color
+ document.querySelector(".chat-box").style.backgroundColor = "#4CAF50"; // Green color
+
+ // Adjust chat messages' background color and bubble tail styles
+ document.querySelectorAll(".bg-blue-200").forEach(function(element) {
+ element.style.backgroundColor = "#357E68"; // Darker green
+ });
+ document.querySelectorAll(".bg-gray-300").forEach(function(element) {
+ element.style.backgroundColor = "#295E4C"; // Darker green
+ element.style.borderLeftColor = "#357E68"; // Border color matching user's bubble
+ });
+
+ // Adjust objectives box background color
+ document.querySelector(".objectives-box").style.backgroundColor = "#4CAF50"; // Green color
+
+ // Adjust task item background color
+ document.querySelectorAll(".task-item").forEach(function(element) {
+ element.style.backgroundColor = "#295E4C"; // Darker green
+ });
+
+ // Adjust task output background color
+ document.querySelectorAll(".task-output").forEach(function(element) {
+ element.style.backgroundColor = "#fffdfd"; // Light gray
+ });
+ '''
+
+# Use the example2 variable in your execute function
+
+
+ messages = [
+ {"role": "user", "content": example_input2},
+ {"role": "assistant", "content": example_output2},
+ {"role": "user", "content": "make my background red."},
+ {"role": "assistant", "content": "document.body.style.backgroundColor = \"red\";\ndocument.body.style.backgroundImage = \"none\";"},
+ {"role": "user", "content": task_prompt}
+ ]
+ print(messages)
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ generated_code = response.choices[0].message['content'].strip()
+
+ # Wrap the generated code with an onload event handler
+ wrapped_code = f'''
+
+ '''
+ return "\n\n" + wrapped_code
+ except Exception as exc:
+ # Log the exception for debugging
+ logging.error(f"Error in PrettyMe skill: {exc}")
+ # Return a user-friendly error message
+ return "An error occurred while processing your request."
diff --git a/classic/babyfoxagi/skills/skill.py b/classic/babyfoxagi/skills/skill.py
new file mode 100644
index 00000000..a291247a
--- /dev/null
+++ b/classic/babyfoxagi/skills/skill.py
@@ -0,0 +1,36 @@
+class Skill:
+ name = 'base skill'
+ description = 'This is the base skill.'
+ api_keys_required = []
+
+ def __init__(self, api_keys, main_loop_function):
+ print(f"Initializing {self.name}")
+ self.api_keys = api_keys
+ self.main_loop_function = main_loop_function
+ missing_keys = self.check_required_keys(api_keys)
+ if missing_keys:
+ print(f"Missing API keys for {self.name}: {missing_keys}")
+ self.valid = False
+ else:
+ self.valid = True
+ for key in self.api_keys_required:
+ if isinstance(key, list):
+ for subkey in key:
+ if subkey in api_keys:
+ setattr(self, f"{subkey}_api_key", api_keys.get(subkey))
+ elif key in api_keys:
+ setattr(self, f"{key}_api_key", api_keys.get(key))
+ print(f"{self.name} initialized successfully")
+
+ def check_required_keys(self, api_keys):
+ missing_keys = []
+ for key in self.api_keys_required:
+ if isinstance(key, list): # If the key is actually a list of alternatives
+ if not any(k in api_keys for k in key): # If none of the alternatives are present
+ missing_keys.append(key) # Add the list of alternatives to the missing keys
+ elif key not in api_keys: # If the key is a single key and it's not present
+ missing_keys.append(key) # Add the key to the missing keys
+ return missing_keys
+
+ def execute(self, params, dependent_task_outputs, objective):
+ raise NotImplementedError('Execute method must be implemented in subclass.')
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/skill_registry.py b/classic/babyfoxagi/skills/skill_registry.py
new file mode 100644
index 00000000..8a145aa2
--- /dev/null
+++ b/classic/babyfoxagi/skills/skill_registry.py
@@ -0,0 +1,107 @@
+import os
+import json
+import openai
+import importlib.util
+import inspect
+from .skill import Skill
+
+class SkillRegistry:
+ def __init__(self, api_keys, main_loop_function, skill_names=None):
+ self.main_loop_function = main_loop_function
+ self.skills = {}
+ skill_files = [f for f in os.listdir('skills') if f.endswith('.py') and f != 'skill.py']
+ for skill_file in skill_files:
+ module_name = skill_file[:-3]
+ if skill_names and module_name not in skill_names:
+ continue
+ module = importlib.import_module(f'skills.{module_name}')
+ for attr_name in dir(module):
+ attr_value = getattr(module, attr_name)
+ if inspect.isclass(attr_value) and issubclass(attr_value, Skill) and attr_value is not Skill:
+ print(f"Attempting to instantiate skill: {attr_name}")
+
+ try:
+ skill = attr_value(api_keys, self.main_loop_function)
+ if skill.valid:
+ self.skills[skill.name] = skill
+ except Exception as e:
+ print(f"Error while instantiating skill '{attr_name}': {e}")
+ skill = attr_value(api_keys, self.main_loop_function)
+ # Print the names and descriptions of all loaded skills
+ skill_info = "\n".join([f"{skill_name}: {skill.description}" for skill_name, skill in self.skills.items()])
+ print(skill_info)
+
+ def load_all_skills(self):
+ skills_dir = os.path.dirname(__file__)
+ for filename in os.listdir(skills_dir):
+ if filename.endswith(".py") and filename not in ["__init__.py", "skill.py", "skill_registry.py"]:
+ skill_name = filename[:-3] # Remove .py extension
+ self.load_skill(skill_name)
+
+ def load_specific_skills(self, skill_names):
+ for skill_name in skill_names:
+ self.load_skill(skill_name)
+
+ def load_skill(self, skill_name):
+ skills_dir = os.path.dirname(__file__)
+ filename = f"{skill_name}.py"
+ if os.path.isfile(os.path.join(skills_dir, filename)):
+ spec = importlib.util.spec_from_file_location(skill_name, os.path.join(skills_dir, filename))
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ for item_name in dir(module):
+ item = getattr(module, item_name)
+ if isinstance(item, type) and issubclass(item, Skill) and item is not Skill:
+ skill_instance = item(self.api_keys)
+ self.skills[skill_instance.name] = skill_instance
+
+ def get_skill(self, skill_name):
+ skill = self.skills.get(skill_name)
+ if skill is None:
+ raise Exception(
+ f"Skill '{skill_name}' not found. Please make sure the skill is loaded and all required API keys are set.")
+ return skill
+
+ def get_all_skills(self):
+ return self.skills
+
+
+ def reflect_skills(self, objective, task_list, task_outputs, skill_descriptions):
+ prompt = (
+ f"You are an expert task manager. Reflect on the objective, entire task list, and the corresponding outputs. "
+ f"Determine whether the available skills were sufficient, and if not, identify and describe new skills that are needed. "
+ f"Provide your response as a JSON array. "
+ f"OBJECTIVE: {objective}."
+ f"AVAILABLE SKILLS: {skill_descriptions}."
+ f"\n###Here is the current task list: {json.dumps(task_list)}"
+ f"\n###Here is the task outputs: {json.dumps(task_outputs)}."
+ f"Missing skills:"
+ )
+ print("\033[90m\033[3m" + "\nReflecting on skills used in task list...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are an AI specializing in reflecting on skills used in tasks and identifying missing skills. You will provide a JSON array as your response."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ skills_analysis = json.loads(result)
+ print(skills_analysis)
+ except Exception as error:
+ print(error)
+
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/skill_saver.py b/classic/babyfoxagi/skills/skill_saver.py
new file mode 100644
index 00000000..9c879784
--- /dev/null
+++ b/classic/babyfoxagi/skills/skill_saver.py
@@ -0,0 +1,58 @@
+from skills.skill import Skill
+import os
+import openai
+
+class SkillSaver(Skill):
+ name = 'skill_saver'
+ description = "A skill that saves code written in a previous step into a file within the skills folder. Not for writing code."
+ api_keys_required = []
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ task_prompt = f"Extract the code and only the code from the dependent task output here: {dependent_task_outputs} \n###\nCODE:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ code = response.choices[0].message['content'].strip()
+ task_prompt = f"Come up with a file name (eg. 'get_weather.py') for the following skill:{code}\n###\nFILE_NAME:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=3000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ file_name = response.choices[0].message['content'].strip()
+ file_path = os.path.join('skills',file_name)
+
+ try:
+ with open(file_path, 'w') as file:
+ file.write(code)
+ print(f"Code saved successfully: {file_name}")
+ except:
+ print("Error saving code.")
+
+ return None
\ No newline at end of file
diff --git a/classic/babyfoxagi/skills/startup_analysis.py b/classic/babyfoxagi/skills/startup_analysis.py
new file mode 100644
index 00000000..f9f5eeb4
--- /dev/null
+++ b/classic/babyfoxagi/skills/startup_analysis.py
@@ -0,0 +1,105 @@
+from skills.skill import Skill
+import openai
+import json
+
+class StartupAnalysis(Skill):
+ name = 'startup_analysis'
+ description = "A tool specialized in providing a detailed analysis of startups using OpenAI's text completion API. Analyzes parameters like customers, ICP, pain points, competitors, etc."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ completion = openai.ChatCompletion.create(
+ model="gpt-4",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a great AI analyst specialized in writing VC investment memos. Write one paragraph each in the third person on customers, ICP, pain points, alternate solutions, competitors, potential partners, key incumbents, history of innovation in the industry, key risks, legal considerations, important figures or influencers, and other recent trends in the space. The user will provide the startup description."
+ },
+ {
+ "role": "user",
+ "content": params
+ # User provides a detailed description of their startup
+ }
+ ],
+ functions=[
+ {
+ "name": "analyze_startup",
+ "description": "Analyze the startup based on various parameters",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "customers": {
+ "type": "string",
+ "description": "Who are the startup's primary customers. Describe in detail in the third person."
+ },
+ "ICP": {
+ "type": "string",
+ "description": "What is the startup's Ideal Customer Profile. Describe in detail in the third person."
+ },
+ "pain_points": {
+ "type": "string",
+ "description": "What are the pain points the startup is trying to solve. Describe in detail in the third person."
+ },
+ "alternate_solutions": {
+ "type": "string",
+ "description": "What are the alternate solutions available in the market. Describe in detail in the third person."
+ },
+ "competitors": {
+ "type": "string",
+ "description": "Who are the startup's main competitors. Describe in detail in the third person."
+ },
+ "potential_partners": {
+ "type": "string",
+ "description": "Who could be the startup's potential partners. Describe in detail in the third person."
+ },
+ "key_incumbents": {
+ "type": "string",
+ "description": "Key incumbents in the industry. Describe in detail."
+ },
+ "history_of_innovation": {
+ "type": "string",
+ "description": "History of innovation in the startup's industry. Describe in detail in the third person."
+ },
+ "key_risks": {
+ "type": "string",
+ "description": "What are the key risks involved in the startup. Describe in detail in the third person."
+ },
+ "legal_considerations": {
+ "type": "string",
+ "description": "Any legal considerations that the startup should be aware of"
+ },
+ "important_figures": {
+ "type": "string",
+ "description": "Important figures or influencers in the industry. Describe in detail in the third person."
+ },
+ "recent_trends": {
+ "type": "string",
+ "description": "What are the recent trends in the startup's industry. Describe in detail."
+ }
+ },
+ "required": [
+ "customers", "ICP", "pain_points", "alternate_solutions",
+ "competitors", "potential_partners", "key_incumbents",
+ "history_of_innovation", "key_risks", "legal_considerations",
+ "important_figures", "recent_trends"
+ ],
+ },
+ },
+ ],
+ function_call={"name": "analyze_startup"}
+ )
+
+ response_data = completion.choices[0]['message']['function_call']['arguments']
+
+ html_content = ""
+ for key, value in json.loads(response_data).items():
+ html_content += f"{key.capitalize()}: {value}\n"
+
+
+ return html_content
diff --git a/classic/babyfoxagi/skills/text_completion.py b/classic/babyfoxagi/skills/text_completion.py
new file mode 100644
index 00000000..89a6c451
--- /dev/null
+++ b/classic/babyfoxagi/skills/text_completion.py
@@ -0,0 +1,31 @@
+from skills.skill import Skill
+import openai
+
+class TextCompletion(Skill):
+ name = 'text_completion'
+ description = "A tool that uses OpenAI's text completion API to generate, summarize, and/or analyze text and code."
+ api_keys_required = ['openai']
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ if not self.valid:
+ return
+
+ task_prompt = f"Complete your assigned task based on the objective and only based on information provided in the dependent task output, if provided. \n###\nYour objective: {objective}. \n###\nYour task: {params} \n###\nDependent tasks output: {dependent_task_outputs} \n###\nYour task: {params}\n###\nRESPONSE:"
+
+ messages = [
+ {"role": "user", "content": task_prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0.4,
+ max_tokens=4000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return "\n\n"+response.choices[0].message['content'].strip()
diff --git a/classic/babyfoxagi/skills/web_search.py b/classic/babyfoxagi/skills/web_search.py
new file mode 100644
index 00000000..74978730
--- /dev/null
+++ b/classic/babyfoxagi/skills/web_search.py
@@ -0,0 +1,155 @@
+from skills.skill import Skill
+from serpapi import GoogleSearch
+import openai
+from bs4 import BeautifulSoup
+import requests
+import re
+import time
+
+headers = {
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36"
+}
+
+class WebSearch(Skill):
+ name = 'web_search'
+ description = 'A tool that performs web searches.'
+ api_keys_required = [['openai'],['serpapi']]
+
+ def __init__(self, api_keys, main_loop_function):
+ super().__init__(api_keys, main_loop_function)
+
+ def execute(self, params, dependent_task_outputs, objective):
+ # Your function goes here
+
+
+ # Modify the query based on the dependent task output
+ if dependent_task_outputs != "":
+ dependent_task = f"Use the dependent task output below as reference to help craft the correct search query for the provided task above. Dependent task output:{dependent_task_outputs}."
+ else:
+ dependent_task = "."
+ query = self.text_completion_tool("You are an AI assistant tasked with generating a short and simple Google search query based on the following task: "+params+"."+dependent_task + "\nExample Task: Perform a web search to find reputable sources of news in the field of AI for today's date.\nExample Query:AI News\nExample Task:Perform a search for Yohei Nakajima at Untapped Capital\nExample Query:Yohei Nakajima Untapped Capital\nTask:"+params+"\nQuery:")
+ print("\033[90m\033[3m"+"Search query: " +str(query)+"\033[0m")
+ # Set the search parameters
+
+ search_params = {
+ "engine": "google",
+ "q": query,
+ "api_key": self.serpapi_api_key,
+ "num": 3
+ }
+ # Perform the web search
+ search_results = GoogleSearch(search_params).get_dict()
+
+ # Simplify the search results
+ search_results = self.simplify_search_results(search_results.get('organic_results', []))
+ print("\033[90m\033[3mCompleted search. Now scraping results.\n\033[0m")
+
+ # Store the results from web scraping
+ results = ""
+ for result in search_results:
+ url = result.get('link')
+ print("\033[90m\033[3m" + "Scraping: "+url+"" + "...\033[0m")
+ content = self.web_scrape_tool({"url": url, "task": params,"objective":objective})
+ results += str(content) + ". "
+ print("\033[90m\033[3m"+str(results[0:100])[0:100]+"...\033[0m")
+ # Process the results and generate a report
+ results = self.text_completion_tool(f"You are an expert analyst combining the results of multiple web scrapes. Rewrite the following information as one cohesive report without removing any facts. Ignore any reports of not having info, unless all reports say so - in which case explain that the search did not work and suggest other web search queries to try. \n###INFORMATION:{results}.\n###REPORT:")
+ time.sleep(1)
+ print("DONE!!!")
+ return results
+
+ def simplify_search_results(self, search_results):
+ simplified_results = []
+ for result in search_results:
+ simplified_result = {
+ "position": result.get("position"),
+ "title": result.get("title"),
+ "link": result.get("link"),
+ "snippet": result.get("snippet")
+ }
+ simplified_results.append(simplified_result)
+ return simplified_results
+
+
+ def text_completion_tool(self, prompt: str):
+ messages = [
+ {"role": "user", "content": prompt}
+ ]
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ temperature=0,
+ max_tokens=2000,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ return response.choices[0].message['content'].strip()
+
+
+ def web_scrape_tool(self, params):
+ content = self.fetch_url_content(params['url'])
+ if content is None:
+ return None
+
+ text = self.extract_text(content)
+ print("\033[90m\033[3m"+"Scrape completed. Length:" +str(len(text))+".Now extracting relevant info..."+"...\033[0m")
+ info = self.extract_relevant_info(params['objective'], text[0:11000], params['task'])
+ links = self.extract_links(content)
+ #result = f"{info} URLs: {', '.join(links)}"
+ result = info
+
+ return result
+
+ def fetch_url_content(self,url: str):
+ try:
+ response = requests.get(url, headers=headers, timeout=10)
+ response.raise_for_status()
+ return response.content
+ except requests.exceptions.RequestException as e:
+ print(f"Error while fetching the URL: {e}")
+ return ""
+
+ def extract_links(self,content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ links = [link.get('href') for link in soup.findAll('a', attrs={'href': re.compile("^https?://")})]
+ return links
+
+ def extract_text(self,content: str):
+ soup = BeautifulSoup(content, "html.parser")
+ text = soup.get_text(strip=True)
+ return text
+
+ def extract_relevant_info(self, objective, large_string, task):
+ chunk_size = 12000
+ overlap = 500
+ notes = ""
+
+ if len(large_string) == 0:
+ print("error scraping")
+ return "Error scraping."
+
+ for i in range(0, len(large_string), chunk_size - overlap):
+
+ print("\033[90m\033[3m"+"Reading chunk..."+"\033[0m")
+ chunk = large_string[i:i + chunk_size]
+
+ messages = [
+ {"role": "system", "content": f"You are an AI assistant."},
+ {"role": "user", "content": f"You are an expert AI research assistant tasked with creating or updating the current notes. If the current note is empty, start a current-notes section by exracting relevant data to the task and objective from the chunk of text to analyze. If there is a current note, add new relevant info frol the chunk of text to analyze. Make sure the new or combined notes is comprehensive and well written. Here's the current chunk of text to analyze: {chunk}. ### Here is the current task: {task}.### For context, here is the objective: {objective}.### Here is the data we've extraced so far that you need to update: {notes}.### new-or-updated-note:"}
+ ]
+
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=messages,
+ max_tokens=2000,
+ n=1,
+ stop="###",
+ temperature=0.7,
+ )
+
+ notes += response.choices[0].message['content'].strip()+". ";
+ time.sleep(1)
+
+ return notes
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/__init__.py b/classic/babyfoxagi/tasks/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/classic/babyfoxagi/tasks/__pycache__/__init__.cpython-38.pyc b/classic/babyfoxagi/tasks/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 00000000..4369fe8c
Binary files /dev/null and b/classic/babyfoxagi/tasks/__pycache__/__init__.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-310.pyc b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-310.pyc
new file mode 100644
index 00000000..255f1809
Binary files /dev/null and b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-310.pyc differ
diff --git a/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-38.pyc b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-38.pyc
new file mode 100644
index 00000000..8ffd4ee9
Binary files /dev/null and b/classic/babyfoxagi/tasks/__pycache__/task_registry.cpython-38.pyc differ
diff --git a/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json b/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json
new file mode 100644
index 00000000..855cd34d
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Create new example objective for researching waterproof kid shoes.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Read the contents of example1.json in the example_objectives folder using the code_reader skill.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Use text_completion to generate a new example objective and task list as JSON based on the extracted information from example1.json.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created example objective and task list as JSON using the objective_saver skill.",
+ "skill": "objective_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/babyfoxagi/tasks/example_objectives/example1.json b/classic/babyfoxagi/tasks/example_objectives/example1.json
new file mode 100644
index 00000000..64a39aa5
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example1.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Create a new skill that writes a poem based on an input.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Read the code in text_completion.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a new skill that uses the concepts from text_completion.py to generate a poem based on user input.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created skill using the skill_saver skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/example_objectives/example2.json b/classic/babyfoxagi/tasks/example_objectives/example2.json
new file mode 100644
index 00000000..889a8bc1
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example2.json
@@ -0,0 +1,33 @@
+[{
+ "objective": "Create a new skill that looks up the weather based on a location input.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Search code examples for free weather APIs to gather information on how to retrieve weather data based on a location input.",
+ "skill": "documentation_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Read the code in text_completion.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Write a new skill that combines the concepts from text_completion.py and the code examples for free weather APIs to implement weather lookup based on a location input.",
+ "skill": "text_completion",
+ "dependent_task_ids": [2, 1],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Save the newly created skill using the skill_saver skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [3],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/example_objectives/example3.json b/classic/babyfoxagi/tasks/example_objectives/example3.json
new file mode 100644
index 00000000..9fdcfdb5
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example3.json
@@ -0,0 +1,40 @@
+[{
+ "objective": "Research untapped.vc",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Conduct a web search on 'untapped.vc' to gather information about the company, its investments, and its impact in the startup ecosystem.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Based on the results from the first web search, perform a follow-up web search to explore specific areas of interest or investment strategies of 'untapped.vc'.",
+ "skill": "web_search",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Use text_completion to summarize the findings from the initial web search on 'untapped.vc' and provide key insights.",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Use text_completion to summarize the findings from the follow-up web search and highlight any additional information or insights.",
+ "skill": "text_completion",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ },
+ {
+ "id": 5,
+ "task": "Combine the summaries from the initial and follow-up web searches to provide a comprehensive overview of 'untapped.vc' and its activities.",
+ "skill": "text_completion",
+ "dependent_task_ids": [3, 4],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/example_objectives/example5.json b/classic/babyfoxagi/tasks/example_objectives/example5.json
new file mode 100644
index 00000000..ff779161
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example5.json
@@ -0,0 +1,26 @@
+[{
+ "objective": "Based on skill_saver.py, write a new skill called objective_saver.py which saves a new example_objective.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Look up the code in skill_saver.py using the code_reader skill to understand its structure and concepts.",
+ "skill": "code_reader",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a new skill called objective_saver.py that saves a new example_objective based on the concepts from skill_saver.py (use text_completion).",
+ "skill": "text_completion",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Save the newly created example_objective using the skill_saver.py skill for future use.",
+ "skill": "skill_saver",
+ "dependent_task_ids": [2],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/babyfoxagi/tasks/example_objectives/example6.json b/classic/babyfoxagi/tasks/example_objectives/example6.json
new file mode 100644
index 00000000..c823c240
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/example6.json
@@ -0,0 +1,19 @@
+[{
+ "objective": "Create new skill for writing a poem called poem_saver, then use the poem_writer skill to write a poem about AI.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Create and save a new skill for writing a poem based on an input.",
+ "skill": "call_babyagi",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Write a poem about AI.",
+ "skill": "poem_writer",
+ "dependent_task_ids": [1],
+ "status": "incomplete"
+ }
+ ]
+}]
diff --git a/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json b/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json
new file mode 100644
index 00000000..4a5fba22
--- /dev/null
+++ b/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json
@@ -0,0 +1,42 @@
+[
+
+{
+ "objective": "Research waterproof kid shoes to find the best options available in the market.",
+ "examples": [
+ {
+ "id": 1,
+ "task": "Search online for popular brands of waterproof kid shoes.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 2,
+ "task": "Read customer reviews and ratings for different waterproof kid shoes.",
+ "skill": "web_search",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 3,
+ "task": "Compare the features and prices of waterproof kid shoes from different brands.",
+ "skill": "text_completion",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 4,
+ "task": "Make a list of the top 5 waterproof kid shoes based on research findings.",
+ "skill": "text_completion",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ },
+ {
+ "id": 5,
+ "task": "Finalize the selection of the best waterproof kid shoes based on research and recommendations.",
+ "skill": "text_completion",
+ "dependent_task_ids": [],
+ "status": "incomplete"
+ }
+ ]
+}]
\ No newline at end of file
diff --git a/classic/babyfoxagi/tasks/task_registry.py b/classic/babyfoxagi/tasks/task_registry.py
new file mode 100644
index 00000000..a06ac8c3
--- /dev/null
+++ b/classic/babyfoxagi/tasks/task_registry.py
@@ -0,0 +1,514 @@
+import openai
+import json
+import threading
+import os
+import numpy as np
+from datetime import datetime
+from collections import defaultdict
+
+class TaskRegistry:
+ def __init__(self):
+ self.tasks = []
+ # Initialize the lock
+ self.lock = threading.Lock()
+ objectives_file_path = "tasks/example_objectives"
+ self.example_loader = ExampleObjectivesLoader(objectives_file_path)
+
+ def load_example_objectives(self, user_objective):
+ return self.example_loader.load_example_objectives(user_objective)
+
+
+ def create_tasklist(self, objective, skill_descriptions):
+ #reflect on objective
+ notes = self.reflect_on_objective(objective,skill_descriptions)
+ #load most relevant object and tasklist from objectives_examples.json
+ example_objective, example_tasklist, example_reflection = self.load_example_objectives(objective)
+
+ prompt = (
+ f"You are an expert task list creation AI tasked with creating a list of tasks as a JSON array, considering the ultimate objective of your team: {objective}. "
+ f"Create a very short task list based on the objective, the final output of the last task will be provided back to the user. Limit tasks types to those that can be completed with the available skills listed below. Task description should be detailed.###"
+ f"AVAILABLE SKILLS: {skill_descriptions}.###"
+ f"RULES:"
+ f"Do not use skills that are not listed."
+ f"Always provide an ID to each task."
+ f"Always include one skill."
+ f"The final task should always output the final result of the overall objective."
+ f"dependent_task_ids should always be an empty array, or an array of numbers representing the task ID it should pull results from."
+ f"Make sure all task IDs are in chronological order.###\n"
+ f"Helpful Notes as guidance:{notes}###\n"
+ f"EXAMPLE OBJECTIVE={json.dumps(example_objective)}"
+ f"TASK LIST={json.dumps(example_tasklist)}"
+ f"OBJECTIVE={objective}"
+ f"TASK LIST="
+ )
+ #print(prompt)
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=2500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ try:
+ task_list = json.loads(result)
+ #print(task_list)
+ self.tasks = task_list
+ except Exception as error:
+ print(error)
+
+
+ def reflect_on_objective(self, objective, skill_descriptions):
+ #load most relevant object and tasklist from objectives_examples.json
+ example_objective, example_tasklist, example_reflection = self.load_example_objectives(objective)
+
+ prompt = (
+ f"You are an Ai specializing in generating helpful thoughts and ideas on tackling an objective, and your task is to think about how to tackle this objective: {objective}. "
+ f"These are the skills available to you: {skill_descriptions}.###"
+ f"Think about what tools and information you need to handle this objective, and which of the available skills would be most helpful to you and writea descriptive note to pass onto a task creation AI."
+ f"Consider the following example objective, tasklist, and reflection as a sample."
+ f"###EXAMPLE OBJECTIVE:{example_objective}."
+ f"###EXAMPLE TASKLIST:{example_tasklist}."
+ f"###REFLECTION FROM EXAMPLE:{example_reflection}."
+ f"###THE AI AGENT'S OBJECTIVE:{example_reflection}."
+ f"###INSTRUCTION: please provide helpful notes for the task creation agent specific to this objective."
+ )
+ #print(prompt)
+ print("\033[90m\033[3m" + "\nInitializing...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k",
+ messages=[
+ {
+ "role": "system",
+ "content": f"You are an Ai specializing in generating helpful thoughts and ideas on tackling an objective, and your task is to think about how to tackle this objective: {objective}. "
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0,
+ max_tokens=250,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print(result)
+ return result
+
+
+ def execute_task(self, i, task, skill_registry, task_outputs, objective):
+ p_nexttask="\033[92m\033[1m"+"\n*****NEXT TASK ID:"+str(task['id'])+"*****\n"+"\033[0m\033[0m"
+ p_nexttask += f"\033[ EExecuting task {task.get('id')}: {task.get('task')}) [{task.get('skill')}]\033[)"
+ print(p_nexttask)
+ # Retrieve the skill from the registry
+ skill = skill_registry.get_skill(task['skill'])
+ # Get the outputs of the dependent tasks
+ dependent_task_outputs = {dep: task_outputs[dep]["output"] for dep in task['dependent_task_ids']} if 'dependent_task_ids' in task else {}
+ # Execute the skill
+ # print("execute:"+str([task['task'], dependent_task_outputs, objective]))
+ task_output = skill.execute(task['task'], dependent_task_outputs, objective)
+ print("\033[93m\033[1m"+"\nTask Output (ID:"+str(task['id'])+"):"+"\033[0m\033[0m")
+ print("TASK: "+str(task["task"]))
+ print("OUTPUT: "+str(task_output))
+ return i, task_output
+
+
+ def reorder_tasks(self):
+ self.tasks= sorted(self.tasks, key=lambda task: task['id'])
+
+
+
+ def add_task(self, task, after_task_id):
+ # Get the task ids
+ task_ids = [t["id"] for t in self.tasks]
+
+ # Get the index of the task id to add the new task after
+ insert_index = task_ids.index(after_task_id) + 1 if after_task_id in task_ids else len(task_ids)
+
+ # Insert the new task
+ self.tasks.insert(insert_index, task)
+ self.reorder_tasks()
+
+
+ def get_tasks(self):
+ return self.tasks
+
+ def update_tasks(self, task_update):
+ for task in self.tasks:
+ if task['id'] == task_update['id']:
+ task.update(task_update)
+ self.reorder_tasks()
+
+
+ def reflect_on_output(self, task_output, skill_descriptions):
+ with self.lock:
+ example = [
+ [
+ {"id": 3, "task": "New task 1 description", "skill": "text_completion_skill",
+ "dependent_task_ids": [], "status": "complete"},
+ {"id": 4, "task": "New task 2 description", "skill": "text_completion_skill",
+ "dependent_task_ids": [], "status": "incomplete"}
+ ],
+ [2, 3],
+ {"id": 5, "task": "Complete the objective and provide a final report",
+ "skill": "text_completion_skill", "dependent_task_ids": [1, 2, 3, 4], "status": "incomplete"}
+ ]
+
+ prompt = (
+ f"You are an expert task manager, review the task output to decide whether any new tasks need to be added, or whether any tasks need to be updated."
+ f"As you add a new task, see if there are any tasks that need to be updated (such as updating dependencies)."
+ f"Use the current task list as reference."
+ f"Do not add duplicate tasks to those in the current task list."
+ f"Only provide JSON as your response without further comments."
+ f"Every new and updated task must include all variables, even they are empty array."
+ f"Dependent IDs must be smaller than the ID of the task."
+ f"New tasks IDs should be no larger than the last task ID."
+ f"Always select at least one skill."
+ f"Task IDs should be unique and in chronological order." f"Do not change the status of complete tasks."
+ f"Only add skills from the AVAILABLE SKILLS, using the exact same spelling."
+ f"Provide your array as a JSON array with double quotes. The first object is new tasks to add as a JSON array, the second array lists the ID numbers where the new tasks should be added after (number of ID numbers matches array), and the third object provides the tasks that need to be updated."
+ f"Make sure to keep dependent_task_ids key, even if an empty array."
+ f"AVAILABLE SKILLS: {skill_descriptions}.###"
+ f"\n###Here is the last task output: {task_output}"
+ f"\n###Here is the current task list: {self.tasks}"
+ f"\n###EXAMPLE OUTPUT FORMAT = {json.dumps(example)}"
+ f"\n###OUTPUT = "
+ )
+ print("\033[90m\033[3m" + "\nReflecting on task output to generate new tasks if necessary...\n" + "\033[0m")
+ response = openai.ChatCompletion.create(
+ model="gpt-3.5-turbo-16k-0613",
+ messages=[
+ {
+ "role": "system",
+ "content": "You are a task creation AI."
+ },
+ {
+ "role": "user",
+ "content": prompt
+ }
+ ],
+ temperature=0.7,
+ max_tokens=1500,
+ top_p=1,
+ frequency_penalty=0,
+ presence_penalty=0
+ )
+
+ # Extract the content of the assistant's response and parse it as JSON
+ result = response["choices"][0]["message"]["content"]
+ print("\n#" + str(result))
+
+ # Check if the returned result has the expected structure
+ if isinstance(result, str):
+ try:
+ task_list = json.loads(result)
+ print("####task_list in function")
+
+ print(task_list)
+ print("####task_list split in function")
+ print(task_list[0], task_list[1], task_list[2])
+ return task_list[0], task_list[1], task_list[2]
+ except Exception as error:
+ print(error)
+
+ else:
+ raise ValueError("Invalid task list structure in the output")
+
+ def get_tasks(self):
+ """
+ Returns the current list of tasks.
+
+ Returns:
+ list: the list of tasks.
+ """
+ return self.tasks
+
+ def get_task(self, task_id):
+ """
+ Returns a task given its task_id.
+
+ Parameters:
+ task_id : int
+ The unique ID of the task.
+
+ Returns:
+ dict
+ The task that matches the task_id.
+ """
+ matching_tasks = [task for task in self.tasks if task["id"] == task_id]
+
+ if matching_tasks:
+ return matching_tasks[0]
+ else:
+ print(f"No task found with id {task_id}")
+ return None
+
+ def print_tasklist(self, tasks):
+ p_tasklist="\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m"
+ for t in tasks:
+ dependent_task_ids = t.get('dependent_task_ids', [])
+ dependent_task = ""
+ if dependent_task_ids:
+ dependent_task = f"\033[31m