+
](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)
+[
](docs/README-vn.md)
+
+
+# Objective
+
+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).
+
+This README will cover the following:
+
+- [How the script works](#how-it-works)
+
+- [How to use the script](#how-to-use)
+
+- [Supported Models](#supported-models)
+
+- [Warning about running the script continuously](#continuous-script-warning)
+
+# 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](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.
+
+
+
+
+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/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.
+
+# How to Use
+
+To use the script, you will need to follow these steps:
+
+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`
+
+All optional values above can also be specified on the command line.
+
+# Running inside a docker container
+
+As a prerequisite, you will need docker and docker-compose installed. Docker desktop is the simplest option https://www.docker.com/products/docker-desktop/
+
+To run the system inside a docker container, setup your .env file as per steps above and then run the following:
+
+```
+docker-compose up
+```
+
+# Supported Models
+
+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.
+
+## Llama
+
+Llama integration requires llama-cpp package. You will also need the Llama model weights.
+
+- **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.**
+
+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.
+
+# 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 API to be set up correctly, so make sure you have set up the API before running the script.
+
+# Contribution
+
+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:
+
+- 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.
+
+A note from @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!
+
+# 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)
+
+[
](https://app.blueprint.ai/github/yoheinakajima/babyagi)
+
+
+# Inspired projects
+
+In the short time since it was release, BabyAGI inspired many projects. You can see them all [here](docs/inspired-projects.md).
+
+# Backstory
+
+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.
+
+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/babyagi/_config.yml b/babyagi/_config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8daa246772b88b3b7b36570849f1a4df3b0c535d
--- /dev/null
+++ b/babyagi/_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/babyagi.py b/babyagi/babyagi.py
new file mode 100755
index 0000000000000000000000000000000000000000..e89bce1ac3a0741423247d4560d8e8e45568322d
--- /dev/null
+++ b/babyagi/babyagi.py
@@ -0,0 +1,643 @@
+#!/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
+from groq import Groq
+
+# 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("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 = os.getenv("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,
+):
+
+ messages=[
+ {
+ "role": "user",
+ "content": "prompt"
+ }
+ ],
+ client = Groq(api_key=os.getenv("api_key"))
+ res = ""
+ completion = client.chat.completions.create(
+ model="llama3-8b-8192",
+ messages=[
+ {
+ "role": "user",
+ "content": "これじゃだめなのか？"
+ }
+ ],
+ temperature=1,
+ max_tokens=1024,
+ top_p=1,
+ stream=True,
+ stop=None,
+ )
+ for chunk in completion:
+ print(chunk.choices[0].delta.content)
+ print(chunk.choices[0].delta.content or "", end="")
+ res += chunk.choices[0].delta.content or ""
+ return res
+
+ 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')
+ for chunk in completion:
+ print(chunk.choices[0].delta.content or "", end="")
+ 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/babycoder/README.md b/babyagi/babycoder/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..53b5fed0ba5100bf35d06f31b0b9c951aff73a4c
--- /dev/null
+++ b/babyagi/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
+
+
+
+
${data.output}
`); + } + }, + error(error) { + console.error(`Error fetching task output for ${taskId}:`, error); + } + }); +} + + + + +$(document).ready(function() { + toggleSendButton(); + loadPreviousMessages(); + loadAllTasks(); + $("#send-btn").on('click', function() { + sendMessage(); + }); + $("#user-input").on('keyup', toggleSendButton); + $("#user-input").on('keydown', function(e) { + if (e.key === 'Enter' && !e.shiftKey && !e.ctrlKey) { + e.preventDefault(); + sendMessage(); + } + }); + $("#task-search").on("keyup", function() { + let value = $(this).val().toLowerCase(); + $(".task-item").filter(function() { + $(this).toggle($(this).find(".task-title").text().toLowerCase().indexOf(value) > -1); + }); + }); + + +}); + + function loadPreviousMessages() { + $.ajax({ + type: 'GET', + url: '/get-all-messages', + dataType: 'json', + success(data) { + data.forEach(message => displayMessage(message.content, message.role)); + scrollToBottom(); + }, + error(error) { + console.error("Error fetching previous messages:", error); + } + }); + } + +function getStatusBadgeHTML(status) { + switch (status) { + case 'ongoing': + return `Ongoing`; + case 'completed': + return `Completed`; + case 'error': + return `Error`; + default: + return `Unknown`; + } +} + +function displayTaskWithStatus(taskDescription, status, skillType = "Unknown Skill", taskId, output = null) { + let statusBadgeHTML = getStatusBadgeHTML(status); + + let skillBadgeHTML = ''; + if (skillType) { + skillBadgeHTML = `${skillType}`; + } + + let outputHTML = output ? `${output}
` : 'No output yet...
'; + + const taskHTML = ` +${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/babyagi/classic/babyfoxagi/public/static/style.css b/babyagi/classic/babyfoxagi/public/static/style.css new file mode 100644 index 0000000000000000000000000000000000000000..8e35631f068b6e62fa4a6ee9219b6721f1f13df4 --- /dev/null +++ b/babyagi/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/babyagi/classic/babyfoxagi/pyproject.toml b/babyagi/classic/babyfoxagi/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..bcb0297b8c6ea40f61091a5ddd7b64c6855836a6 --- /dev/null +++ b/babyagi/classic/babyfoxagi/pyproject.toml @@ -0,0 +1,28 @@ +[tool.poetry] +name = "python-template" +version = "0.1.0" +description = "" +authors = ["Your Name})
'
+ print(f"html_code: {html_code}")
+
+ return html_code
diff --git a/babyagi/classic/babyfoxagi/skills/play_music.py b/babyagi/classic/babyfoxagi/skills/play_music.py
new file mode 100644
index 0000000000000000000000000000000000000000..e64d75bd226d67bf1844e5ad8a20f862d10c2801
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/pretty_me.py b/babyagi/classic/babyfoxagi/skills/pretty_me.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc10b637f974baac0855a24b0bf4f0c4a18d302b
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/skill.py b/babyagi/classic/babyfoxagi/skills/skill.py
new file mode 100644
index 0000000000000000000000000000000000000000..a291247abfcbe4864f3ae7437a4c48ae57f7b0a0
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/skill_registry.py b/babyagi/classic/babyfoxagi/skills/skill_registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a145aa2246ed1300ad1c4b50a21a061764a0596
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/skill_saver.py b/babyagi/classic/babyfoxagi/skills/skill_saver.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c8797845a33afe8bbfcb23813c1736e4086e116
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/startup_analysis.py b/babyagi/classic/babyfoxagi/skills/startup_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9f5eeb45cc9759cecee809bef3447920a68eab7
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/text_completion.py b/babyagi/classic/babyfoxagi/skills/text_completion.py
new file mode 100644
index 0000000000000000000000000000000000000000..89a6c4516f9d449d428f47d48f2c6a24d0ea2ea8
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/skills/web_search.py b/babyagi/classic/babyfoxagi/skills/web_search.py
new file mode 100644
index 0000000000000000000000000000000000000000..74978730267adcea13201efa1c104882e7b5e8da
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/__init__.py b/babyagi/classic/babyfoxagi/tasks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/babyagi/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/create_poemskill_and_use.json
new file mode 100644
index 0000000000000000000000000000000000000000..855cd34dc8f3d1705d952d300087452839ec9634
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/example_objectives/example1.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/example1.json
new file mode 100644
index 0000000000000000000000000000000000000000..64a39aa5256609c43537f563d040f880bd10d4aa
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/example_objectives/example2.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/example2.json
new file mode 100644
index 0000000000000000000000000000000000000000..889a8bc1bc6f2fa676f84c779e1707837cafc0ea
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/example_objectives/example3.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/example3.json
new file mode 100644
index 0000000000000000000000000000000000000000..9fdcfdb576b0091c3f125fd53d1575af0730ad11
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/example_objectives/example5.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/example5.json
new file mode 100644
index 0000000000000000000000000000000000000000..ff779161e032a0184dddb0acfb37149141585596
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/example_objectives/example6.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/example6.json
new file mode 100644
index 0000000000000000000000000000000000000000..c823c24037b7d916502ebe02f7c6a2996f6489b9
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json b/babyagi/classic/babyfoxagi/tasks/example_objectives/waterproof_kid_shoes_research.json
new file mode 100644
index 0000000000000000000000000000000000000000..4a5fba2263cdcb8c61265047054806391f367f62
--- /dev/null
+++ b/babyagi/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/babyagi/classic/babyfoxagi/tasks/task_registry.py b/babyagi/classic/babyfoxagi/tasks/task_registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..a06ac8c3e250ba9662922857b7e20a69e6fa82ef
--- /dev/null
+++ b/babyagi/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](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/babyagi/docs/README-cn.md b/babyagi/docs/README-cn.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd2ea434709d14d3a43e57608040c4f4a7dc87e4
--- /dev/null
+++ b/babyagi/docs/README-cn.md
@@ -0,0 +1,94 @@
+](docs/README-pt-br.md)
+[](docs/README-ru.md)
+[](docs/README-si.md)
+[](docs/README-tr.md)
+[](docs/README-ua.md)
+[](docs/README-cn.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)
+
+- [关于连续运行脚本的警告](#continous-script-warning)
+
+# 这怎么玩?
+
+脚本通过运行一个无限循环来工作, 该循环执行以下步骤:
+
+1. 从任务列表中提取第一个任务.
+2. 将任务发送给执行代理, 该代理使用 OpenAI API 根据上下文完成任务.
+3. 丰润结果并将其存储在 Pinecone 中.
+4. 基于目标和前一个任务的结果创建新任务, 并根据优先级对任务列表进行排序.
+
+
+函数 execution_agent()使用 OpenAI API. 它接受两个参数：目标和任务. 然后它向 OpenAI 的 API 发送一个 prompt(提示), 该 API 返回任务的结果. Prompt 包括 AI 系统任务的描述, 目标和任务本身. 结果然后以 string 形式返回.
+
+task_creation_agent()函数使用 OpenAI API 根据目标和前一个任务的结果创建新任务. 该函数接受 4 个参数：目标, 前一个任务的结果, 任务描述和当前任务列表. 然后它向 OpenAI 的 API 发送一个 prompt, 该 API 返回一个新任务的 string 列表. 函数然后将新任务作为字典列表返回, 其中每个字典包含任务的名称.
+
+prioritization_agent()函数使用 OpenAI API 对任务列表进行重新排序. 该函数接受一个参数, 即当前任务的 ID. 它向 OpenAI 的 API 发送一个 prompt, 该 API 返回一个重新排序的任务列表(以数字编号).
+
+最后, 脚本使用 Pinecone 存储和检索任务结果以获取上下文. 脚本根据 YOUR_TABLE_NAME 变量中指定的表名创建一个 Pinecone 索引. 然后 Pinecone 将任务结果与任务名称和任何其他元数据(metadata)一起存储在索引中.
+
+# 咋用
+
+要使用此脚本, 您需要按照以下步骤操作:
+
+1. 通过 `git clone https://github.com/yoheinakajima/babyagi.git` 克隆 repository(仓库), 然后使用`cd`进入克隆的 repo.
+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 变量中设置系统的第一个任务.
+7. 运行脚本.
+
+上面的所有可选值也可以在命令行中指定.
+
+# 支持的模型
+
+此脚本适用于所有 OpenAI 模型, 以及 Llama (通过 Llama.cp). 默认模型是 gpt-3.5-turbo. 要使用不同的模型, 请通过 OPENAI_API_MODEL 指定, 或者使用命令行.
+
+## Llama
+
+下载最新版的[Llama.cpp](https://github.com/ggerganov/llama.cpp) 并按照说明进行编译. 您还需要 Llama 模型的权重.
+
+- **在任何情况下, 都不要在此 repo(仓库)的任何地方（包括问题, 讨论或拉取请求中）分享 IPFS, 磁力链接或任何其他模型下载链接. 它们将立即被删除.**
+
+然后将 `llama/main` 链接到 llama.cpp/main, 将 `models` 链接到存放 Llama 模型权重的文件夹. 接着传入参数 `OPENAI_API_MODEL=llama` 或 `-l` 运行脚本.
+
+# 高能警告
+
+该脚本被设计为作为任务管理系统的一部分持续运行. 持续运行此脚本可能导致 API 的**使用费超高**, 请务必谨慎使用并后果自负. 此外, 脚本需要正确设置 OpenAI 和 Pinecone API, 因此请确保在运行脚本之前已经设置了 API.
+
+# 贡献
+
+不管咋说, BabyAGI 还处于起步阶段, 我们仍在确定其发展方向以及实现目标所需的步骤. 目前, BabyAGI 的一个关键设计目标是保持 **简单**, 以便于理解和构建. 为了保持这种简单性, 我们恳请您在提交 PR 时遵循以下准则：
+
+- 集中于小型, 模块化的修改, 而不是大规模的重构.
+- 在引入新功能时, 提供详细的描述, 说明您要解决的具体用例.
+
+@yoheinakajima 发的的小纸条 (Apr 5th, 2023):
+
+> 我知道 PR 的数量在不断增加, 感谢你们的耐心 - 因为我既是 GitHub/OpenSource 的新手, 又没有合理安排本周的时间. Re: 关于发展方向, 我一直在保持简单与扩展之间徘徊 - 目前倾向于保持 核心的 Baby AGI 尽量简单, 并将其作为支持和推广扩展的不同方法的平台（例如, 将 BabyAGIxLangchain 作为一个方向）. 我相信有各种有建设性的方法值得探索, 那么在专门的地方进行比较和讨论能够见证价值的. 更多更新即将到来.
+
+我是 GitHub 和 open source 的新手, 所以请耐心等待, 因为我正在学习如何管理好这个项目. 白天我经营一家风投公司, 所以我通常会在晚上哄娃睡着之后检查 PR 和 issues - 可能不是每个晚上. 我对引入支持的想法持开放态度, 将很快更新这一部分（期望, 愿景等）. 正在与很多人交流学习 - 敬请期待更新！
+
+# 背景故事
+
+BabyAGI 是一个精简版本, 它的原版[Task-Driven Autonomous Agent(任务驱动的自驱代理)](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20) 是在 Twitter 分享的(Mar 28, 2023). 这个版本缩减到了 140 行：13 条注释, 22 个空白行, 以及 105 行代码. Repo 的名称源于对原始自驱代理的反馈 - 作者并不是想暗示这就是 AGI.
+
+[@yoheinakajima](https://twitter.com/yoheinakajima)用爱发电创作此 repo, 他碰巧是一位 VC(风险投资人) (很想看看你们在创造什么!)
diff --git a/babyagi/docs/README-de.md b/babyagi/docs/README-de.md
new file mode 100644
index 0000000000000000000000000000000000000000..99061f555a42863c362dc4f0550ab32b78e68387
--- /dev/null
+++ b/babyagi/docs/README-de.md
@@ -0,0 +1,103 @@
+](./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/babyagi/docs/README-in.md b/babyagi/docs/README-in.md
new file mode 100644
index 0000000000000000000000000000000000000000..a192f32f940e76ca2653ebc20e7f5a07798b6cbb
--- /dev/null
+++ b/babyagi/docs/README-in.md
@@ -0,0 +1,100 @@
+](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/babyagi/docs/README-ko.md b/babyagi/docs/README-ko.md
new file mode 100644
index 0000000000000000000000000000000000000000..e20e858887ac9294db025e9a396e0845dc4b5e6a
--- /dev/null
+++ b/babyagi/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/babyagi/docs/README-pl.md b/babyagi/docs/README-pl.md
new file mode 100644
index 0000000000000000000000000000000000000000..648d45ebd135fedae56b547f916a87dd84b65ef9
--- /dev/null
+++ b/babyagi/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/babyagi/docs/README-pt-br.md b/babyagi/docs/README-pt-br.md
new file mode 100644
index 0000000000000000000000000000000000000000..514acb7055900186d78c561a42c695864c0d43ae
--- /dev/null
+++ b/babyagi/docs/README-pt-br.md
@@ -0,0 +1,83 @@
+](docs/README-ru.md)
+[
](README.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/babyagi/docs/README-ua.md b/babyagi/docs/README-ua.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac5532e8333ecb83e4db06485c442db7aff2dc02
--- /dev/null
+++ b/babyagi/docs/README-ua.md
@@ -0,0 +1,79 @@
+](https://app.blueprint.ai/github/yoheinakajima/babyagi)
+
+# Các dự án được truyền cảm hứng
+
+Trong thời gian ngắn kể từ khi nó được phát hành, BabyAGI đã truyền cảm hứng cho nhiều dự án.
+Bạn có thể xem tất cả chúng [tại đây](docs/inspired-projects.md).
+
+# Nguồn gốc
+
+BabyAGI là phiên bản rút gọn của [Task-Driven Autonomous Agent](https://twitter.com/yoheinakajima/status/1640934493489070080?s=20)
+(28 tháng 3 năm 2023) được chia sẻ trên Twitter. Phiên bản này giảm xuống còn 140 dòng: 13 comment, 22 dòng trống, và 105 dòng code.
+Tên của repository được đặt ra sau khi phản ứng với agent tự động ban đầu - tác giả không có ý định ngụ ý rằng đây là AGI.
+
+Made with love bởi [@yoheinakajima](https://twitter.com/yoheinakajima), một nhà đầu tư mạo hiểm (và rất muốn biết bạn đang xây dựng cái gì!)
diff --git a/babyagi/docs/README-zh-tw.md b/babyagi/docs/README-zh-tw.md
new file mode 100644
index 0000000000000000000000000000000000000000..6c80ece4b88924bf24e7f7bb4674862f6bba2acc
--- /dev/null
+++ b/babyagi/docs/README-zh-tw.md
@@ -0,0 +1,101 @@
+](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/babyagi/docs/baby-agi-fig-ar.png b/babyagi/docs/baby-agi-fig-ar.png
new file mode 100644
index 0000000000000000000000000000000000000000..8735c429101774ce0e2f75231bdc09436bc0eb2f
Binary files /dev/null and b/babyagi/docs/baby-agi-fig-ar.png differ
diff --git a/babyagi/docs/babyagi.png b/babyagi/docs/babyagi.png
new file mode 100644
index 0000000000000000000000000000000000000000..602302e300c02be6b60ebbeaa1dd2a9a72dba2e2
Binary files /dev/null and b/babyagi/docs/babyagi.png differ
diff --git a/babyagi/docs/inspired-projects.md b/babyagi/docs/inspired-projects.md
new file mode 100644
index 0000000000000000000000000000000000000000..16495946ff2b11a082e1fe36b0574de3bca16b9c
--- /dev/null
+++ b/babyagi/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/babyagi/docs/weaviate.md b/babyagi/docs/weaviate.md
new file mode 100644
index 0000000000000000000000000000000000000000..82497a320a694a8697863946de49debed74d68a9
--- /dev/null
+++ b/babyagi/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/babyagi/extensions/__init__.py b/babyagi/extensions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/babyagi/extensions/argparseext.py b/babyagi/extensions/argparseext.py
new file mode 100644
index 0000000000000000000000000000000000000000..752390cc63cbbcebaed8b40ffa4e198769b543d7
--- /dev/null
+++ b/babyagi/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='