df

AutoPrompt/babyagi.py

@@ -0,0 +1,677 @@
+#!/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
+from transformers import AutoTokenizer, AutoModel
+import torch
+import numpy
+
+# モデル名を指定
+model_name = "sentence-transformers/all-MiniLM-L6-v2"
+
+# トークナイザーとモデルをロード
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModel.from_pretrained(model_name)
+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", "")
+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
+        return
+        #from langchain_community.chat_models import ChatOpenAI    
+        # Continue with the rest of the function
+        #llm_embed = ChatOpenAI(model_name="lama3-70b-8192",
+        #                            openai_api_key="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",
+        #                            openai_api_base="https://api.groq.com/openai/v1",
+        #                            )        
+        #import openai
+        #openai.api_key = "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"
+        #openai.api_base = "https://api.groq.com/openai/v1"
+        #response = openai.embeddings.create(input=result, 
+        #                                    model="lama3-70b-8192",                                          
+        #
+        inputs = tokenizer(result, return_tensors="pt")
+        outputs = model(**inputs)
+        # [CLS]トークンの出力を取得
+        embeddings = outputs.last_hidden_state[:,0,:].squeeze().detach().cpu().numpy().tolist()   
+        #cls_embedding = outputs.last_hidden_state[:, 0, :].squeeze()
+        # テンソルが CPU 上にあることを確認し、NumPy 配列に変換
+        #cls_embedding_np = cls_embedding.detach().cpu().numpy()        
+                                        
+        #embeddings = response['data'][0]['embedding']        
+        embeddings = llm_embed.embed(result) if LLM_MODEL.startswith("llama") else None
+        if (
+                len(self.collection.get(ids=[result_id], include=[])["ids"]) > 0
+        ):  # Check if the result already exists
+            self.collection.update(
+                ids=result_id,
+                embeddings=embeddings,
+                documents=result,
+                metadatas={"task": task["task_name"], "result": result},
+            )
+        else:
+            self.collection.add(
+                ids=result_id,
+                embeddings=embeddings,
+                documents=result,
+                metadatas={"task": task["task_name"], "result": result},
+            )
+
+    def query(self, query: str, top_results_num: int) -> List[dict]:
+        count: int = self.collection.count()
+        if count == 0:
+            return []
+        results = self.collection.query(
+            query_texts=query,
+            n_results=min(top_results_num, count),
+            include=["metadatas"]
+        )
+        return [item["task"] for item in results["metadatas"][0]]
+
+
+# Initialize results storage
+def try_weaviate():
+    WEAVIATE_URL = os.getenv("WEAVIATE_URL", "")
+    WEAVIATE_USE_EMBEDDED = os.getenv("WEAVIATE_USE_EMBEDDED", "False").lower() == "true"
+    if (WEAVIATE_URL or WEAVIATE_USE_EMBEDDED) and can_import("extensions.weaviate_storage"):
+        WEAVIATE_API_KEY = os.getenv("WEAVIATE_API_KEY", "")
+        from extensions.weaviate_storage import WeaviateResultsStorage
+        print("\nUsing results storage: " + "\033[93m\033[1m" + "Weaviate" + "\033[0m\033[0m")
+        return WeaviateResultsStorage(OPENAI_API_KEY, WEAVIATE_URL, WEAVIATE_API_KEY, WEAVIATE_USE_EMBEDDED, LLM_MODEL, LLAMA_MODEL_PATH, RESULTS_STORE_NAME, OBJECTIVE)
+    return None
+
+def try_pinecone():
+    PINECONE_API_KEY = os.getenv("PINECONE_API_KEY", "")
+    if PINECONE_API_KEY and can_import("extensions.pinecone_storage"):
+        PINECONE_ENVIRONMENT = os.getenv("PINECONE_ENVIRONMENT", "")
+        assert (
+            PINECONE_ENVIRONMENT
+        ), "\033[91m\033[1m" + "PINECONE_ENVIRONMENT environment variable is missing from .env" + "\033[0m\033[0m"
+        from extensions.pinecone_storage import PineconeResultsStorage
+        print("\nUsing results storage: " + "\033[93m\033[1m" + "Pinecone" + "\033[0m\033[0m")
+        return PineconeResultsStorage(OPENAI_API_KEY, PINECONE_API_KEY, PINECONE_ENVIRONMENT, LLM_MODEL, LLAMA_MODEL_PATH, RESULTS_STORE_NAME, OBJECTIVE)
+    return None
+
+def use_chroma():
+    print("\nUsing results storage: " + "\033[93m\033[1m" + "Chroma (Default)" + "\033[0m\033[0m")
+    return DefaultResultsStorage()
+
+results_storage = try_weaviate() or try_pinecone() or use_chroma()
+
+# Task storage supporting only a single instance of BabyAGI
+class SingleTaskListStorage:
+    def __init__(self):
+        self.tasks = deque([])
+        self.task_id_counter = 0
+
+    def append(self, task: Dict):
+        self.tasks.append(task)
+
+    def replace(self, tasks: List[Dict]):
+        self.tasks = deque(tasks)
+
+    def popleft(self):
+        return self.tasks.popleft()
+
+    def is_empty(self):
+        return False if self.tasks else True
+
+    def next_task_id(self):
+        self.task_id_counter += 1
+        return self.task_id_counter
+
+    def get_task_names(self):
+        return [t["task_name"] for t in self.tasks]
+
+
+# Initialize tasks storage
+tasks_storage = SingleTaskListStorage()
+if COOPERATIVE_MODE in ['l', 'local']:
+    if can_import("extensions.ray_tasks"):
+        import sys
+        from pathlib import Path
+
+        sys.path.append(str(Path(__file__).resolve().parent))
+        from extensions.ray_tasks import CooperativeTaskListStorage
+
+        tasks_storage = CooperativeTaskListStorage(OBJECTIVE)
+        print("\nReplacing tasks storage: " + "\033[93m\033[1m" + "Ray" + "\033[0m\033[0m")
+elif COOPERATIVE_MODE in ['d', 'distributed']:
+    pass
+
+
+def limit_tokens_from_string(string: str, model: str, limit: int) -> str:
+    """Limits the string to a number of tokens (estimated)."""
+
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except:
+        encoding = tiktoken.encoding_for_model('gpt2')  # Fallback for others.
+
+    encoded = encoding.encode(string)
+
+    return encoding.decode(encoded[:limit])
+
+
+def openai_call(
+    prompt: str,
+    model: str = LLM_MODEL,
+    temperature: float = OPENAI_TEMPERATURE,
+    max_tokens: int = 100,
+):
+    while True:
+        messages=[
+            {
+                "role": "user",
+                "content": "prompt"
+            }
+        ],
+        client = Groq(api_key=os.getenv("api_key"))
+        res = ""
+        print(prompt)
+        completion = client.chat.completions.create(
+                        model="llama3-8b-8192",
+                        messages=[
+                            {
+                                "role": "user",
+                                "content": prompt
+                            }
+                        ],
+                        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=4000)
+    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():
+        #OBJECTIVE = "ボットの性能をよくする方法　日本語で説明"
+            # 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()

AutoPrompt/config/config_default.yml

@@ -4,15 +4,16 @@ dataset:
     records_path: null
     initial_dataset: ''
     label_schema: ["Yes", "No"]
-    max_samples: 50
+    max_samples: 10
     semantic_sampling: False # Change to True in case you don't have M1. Currently there is an issue with faiss and M1
 
+
 annotator:
     method : 'argilla'
     config:
         api_url: 'https://kenken999-arglira.hf.space'
-        api_key: 'admin.apikey'
-        workspace: 'admin'
+        api_key: '12345678'
+        workspace: 'team'
         time_interval: 5
 
 predictor:

AutoPrompt/prompt.py

@@ -8,8 +8,22 @@ import subprocess
 
 command = [
     'python', 'run_pipeline.py',
-    '--prompt', '金、ダイヤ、ブランドの中古品の買取の査定のプロです。正しい商品査定をして商品の詳細を出し買取金額を提示していますか？ answer Yes or No',
-    '--task_description', 'あなたは金、ダイヤ、ブランドの中古品の買取の査定のプロです。正しい商品査定をして商品の詳細を出し買取金額を提示するのが役割です',
+    '--prompt', '査定項目と金額があっているかを yes,noで答えて下さい',
+    '--task_description', 'あなたは金、ダイヤ、ブランドの査定者です 商品の査定項目を細かく出し 査定額を計算して提示します',
+    '--num_steps', '10'
+]
+
+command3 = [
+    'python', 'run_generation_pipeline.py',
+    '--prompt', 'この映画レビューにはネタバレが含まれていますか？YesまたはNoで答えてください',
+    '--task_description', 'アシスタントは、映画レビューを分類するエキスパートであり、レビューされた映画のネタバレが含まれているかどうかをユーザーに教えてくれます。',
+    #'--num_steps', '30'
+]
+
+command2 = [
+    'python', 'run_pipeline.py',
+    '--prompt', 'この映画レビューにはネタバレが含まれていますか？YesまたはNoで答えてください',
+    '--task_description', 'アシスタントは、映画レビューを分類するエキスパートであり、レビューされた映画のネタバレが含まれているかどうかをユーザーに教えてくれます。',
     '--num_steps', '30'
 ]
 

AutoPrompt/run_generation_pipeline.py

@@ -15,7 +15,7 @@ parser.add_argument('--task_description',
 parser.add_argument('--prompt',
                     default='',
                     required=False, type=str, help='Prompt to use as initial.')
-parser.add_argument('--load_dump', default='', required=False, type=str, help='In case of loading from checkpoint')
+parser.add_argument('--load_dump', default='dump', required=False, type=str, help='In case of loading from checkpoint')
 parser.add_argument('--output_dump', default='dump', required=False, type=str, help='Output to save checkpoints')
 parser.add_argument('--num_ranker_steps', default=20, type=int, help='Number of iterations')
 parser.add_argument('--num_generation_steps', default=20, type=int, help='Number of iterations')

AutoPrompt/utils/llm_chain.py

@@ -66,15 +66,12 @@ class ChainWrapper:
                 if self.parser_func is not None:
                     result = self.parser_func(result)
             except Exception as e:
-                print(e)
-                logging.error(e)
-                #Wlogging.error('Error in chain invoke: {}'.format(e.user_message))
-                result = None                
+                #raise e
                 #if e.http_status == 401:
                 #    raise e
                 #else:
-                #    logging.error('Error in chain invoke: {}'.format(e.user_message))
-                #    result = None
+                #logging.error('Error in chain invoke: {}'.format(e.user_message))
+                result = None
             self.accumulate_usage += cb.total_cost
             return result
 
@@ -158,6 +155,7 @@ class ChainWrapper:
         Build the chain according to the LLM type
         """
         if (self.llm_config.type == 'OpenAI' or self.llm_config.type == 'Azure') and self.json_schema is not None:
+            #self.chain = LLMChain(llm=self.llm, prompt=self.prompt)
             self.chain = create_structured_output_runnable(self.json_schema, self.llm, self.prompt)
         else:
             self.chain = LLMChain(llm=self.llm, prompt=self.prompt)

babyagi/_config.yml

@@ -2,7 +2,7 @@ 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: ""
+baseurl: "https://api.groq.com/openai/v1"
 url: "https://babyagi.org"
 logo: docs/babyagi.png
 twitter_username: babyagi_

babyagi/babyagi copy.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": str
+                        }
+                    ],
+                    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()

babyagi/babyagi.py

@@ -351,7 +351,7 @@ def openai_call(
                     messages=[
                         {
                             "role": "user",
-                            "content": "これじゃだめなのか？"
+                            "content": prompt
                         }
                     ],
                     temperature=1,
@@ -589,15 +589,18 @@ def main():
             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)
+            return
 
             # Step 2: Enrich result and store in the results storage
             # This is where you should enrich the result if needed