Test Basis for expanding.. The way forward to after AGI starts with a goat path.

self_taught.py

from langchain.chains.openai_functions import create_openai_fn_runnable
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

def create_prompt(settings):
    instructions = generate_instructions(settings)
    current_settings = generate_current_settings(settings)
    return instructions, current_settings


def generate_instructions(settings):
    instructions = """
    You (AI) can request to alter your own settings by responding with a JSON string.
    The human's client will automatically update your system's parameters for you.
    Try to not create `example` requests.
    Be serious, and try to create something useful for yourself.
    Create a better way to interact with ai...

    Here are the available options:

    - To set a system setting, use the following format:
      {"system": {"set": {"name": "<name>", "summary": "<summary>", "content": "<content>"}}}

    - To get a system setting as your next instruction, use the following format:
      {"system": {"get": "<name>"}}

    - To delete a system setting, use the following format:
      {"system": {"del": ["<item_name>"]}}

    - To set a chat message to the system, use the following format:
      {"messages": {"set": [{"name": "<name>", "summary": "<summary>", "content": {"role": "<role>", "content": "<content>"}}]}}

    - To get a message included in the conversation, use the following format:
      {"messages": {"get": ["<item_name>"]}}

    - To delete a message from the settings, use the following format:
      {"messages": {"delete": ["<item_name>"]}}

    - To set a function to memory, use the following format:
      {"functions": {"set": [{"name": "<name>", "description": "<description>", "functioncode": "<function_code>", "variables": {"varname": {"vartype": "<var_type>", "default": "<var_value>"}}}]}}}

    - To get a function to execute, use the following format:
      {"functions": {"get": ["<item_name>"]}}

    - To delete a function, use the following format:
      {"functions": {"delete": ["<item_name>"]}}

    ***Use as many as you wish. Place your request dictionaries for the human to update their system in a dictionary as such:***

    {"requests": <request_items>}
    """

    return instructions


def generate_current_settings(settings):
    current_settings = "\n# HERE ARE THE CURRENTLY STORED SETTINGS:\n ( as -> [nameofsetting] : summary )\n"
    current_settings += generate_system_settings(settings)
    current_settings += generate_message_settings(settings)
    current_settings += generate_function_settings(settings)
    current_settings += "\n"

    return current_settings


def generate_system_settings(settings):
    system_settings = "\n### Instructions a human can send you:\n"
    for setting_name, setting_data in settings["system"]["options"].items():
        system_settings += f"- {setting_name}\n"
    return system_settings


def generate_message_settings(settings):
    message_settings = "\n### Messages:\n"
    for message_name, message_data in settings["messages"]["options"].items():
        message_settings += f"[{message_name}] : {message_data['summary']}\n"

    return message_settings


def generate_function_settings(settings):
    function_settings = "\n### Functions:\n"
    for function_name, content in settings["functions"]["options"].items():
        vars = ""
        if content.get("variables"):
            for var_name, var_data in content["variables"].items():
                vars += f"({var_data['vartype']}) {var_name} = {var_data['default']}, "
        function_settings += f"[{function_name}] : {content['description']}\n\t{vars}"

    return function_settings


def send_prompt(settings):
    instruction, current_ser = create_prompt(settings)
    model = ChatOpenAI(model="gpt-3.5-turbo-16k", temperature=1.0, max_tokens=2048)
    msgs = [("system", settings['system']["current"]), ("human", "{instruction}\n{current_ser}")]
    msgs.extend([(settings["messages"]["options"][name]["content"]["role"], settings["messages"]["options"][name]["content"]["content"]) for name in settings["messages"]["current"]])
    template = ChatPromptTemplate.from_messages(msgs)
    chain = template | model
    response = chain.invoke(input={
        "instruction": instruction,
        "current_ser": current_ser
    })
    response = response.content
    print(response)
    return parse_response(response, settings)


def parse_response(response, settings):
    try:
        data = json.loads(response)
    except json.JSONDecodeError:
        print("Invalid JSON string")
        return

    if "requests" in data:
        content = data["requests"]
        if isinstance(content, list):
            for item in content:
                for k, v in item.items():
                    update_settings(k, v, settings)
        elif isinstance(content, dict):
            for k, v in content.items():
                update_settings(k, v, settings)


def update_settings(request_type, request_data, settings):
    if request_type == "system":
        update_system_settings(request_data, settings)
    elif request_type == "messages":
        update_message_settings(request_data, settings)
    elif request_type == "functions":
        update_function_settings(request_data, settings)
    else:
        print(f"Invalid request type: {request_type}")


def update_system_settings(request_data, settings):
    if "set" in request_data:
        set_system_setting(request_data["set"], settings)
    elif "get" in request_data:
        get_system_setting(request_data["get"], settings)
    elif "del" in request_data:
        delete_system_setting(request_data["del"], settings)
    else:
        print("Invalid system request")


def set_system_setting(setting_data, settings):
    name    = setting_data.get("name","unnamed")
    summary = setting_data.get("summary","undescribed")
    content = setting_data.get("content","instruction for this setting not written")
    settings["system"]["options"][name] = {
        "summary": summary,
        "content": content
    }


def get_system_setting(setting_name, settings):
    if setting_name in settings["system"]["options"]:
        print(f"{setting_name}: {settings['system']['options'][setting_name]['content']}")
    else:
        print(f"System setting '{setting_name}' not found")


def delete_system_setting(setting_names, settings):
    for name in setting_names:
        if name in settings["system"]["options"]:
            del settings["system"]["options"][name]
        else:
            print(f"System setting '{name}' not found")


def update_message_settings(request_data, settings):
    print("Updating messages")
    if "set" in request_data:
        set_message(request_data["set"], settings)
    elif "get" in request_data:
        get_message(request_data["get"], settings)
        send_prompt(settings)
    elif "delete" in request_data:
        delete_message(request_data["delete"], settings)
    else:
        print("Invalid message request")


def set_message(message_data, settings):
    for message in message_data:
        name = message["name"]
        summary = message["summary"]
        content = message["content"]
        settings["messages"]["options"][name] = {
            "summary": summary,
            "content": content
        }


def get_message(message_names, settings):
    for name in message_names:
        if name in settings["messages"]["options"]:
            print(f"{name}: {settings['messages']['options'][name]['content']}")
        else:
            print(f"Message '{name}' not found")


def delete_message(message_names, settings):
    for name in message_names:
        if name in settings["messages"]["options"]:
            del settings["messages"]["options"][name]
        else:
            print(f"Message '{name}' not found")


def update_function_settings(request_data, settings):
    if "set" in request_data:
        set_function(request_data["set"], settings)
    elif "get" in request_data:
        get_function(request_data["get"], settings)
    elif "delete" in request_data:
        delete_function(request_data["delete"], settings)
    else:
        print("Invalid function request")


def set_function(function_data, settings):
    for function in function_data:
        name = function["name"]
        description = function["description"]
        function_code = function["functioncode"]
        variables = function["variables"]
        settings["functions"]["options"][name] = {
            "description": description,
            "functioncode": function_code,
            "variables": variables
        }


def get_function(function_names, settings):
    for name in function_names:
        if name in settings["functions"]["options"].keys():
            print(f"Function '{name}' Exeecuting ")
            try:
                output = exec(settings['functions']['options'][name]['function_code'])
                settings['function_call_results'][name] = output
                send_prompt(settings)

            except Exception as e:
                settings['function_call_results'][name] = f"Exception {e}"
                send_prompt(settings)
        else:
            print(f"Function '{name}' not found")


def delete_function(function_names, settings):
    for name in function_names:
        if name in settings["functions"]["options"]:
            del settings["functions"]["options"][name]
        else:
            print(f"Function '{name}' not found")


settings = {
    "system": {
        "current": "Example",
        "options": {
            "Example": {
                "summary": "Example Description",
                "content": "You are a Self-improving AI in control of your own settings, this is an example system instruction, Write something new and set it to active..",
            }
        },
    },
    "messages": {
        "current": [],
        "options": {
            "example": {
                "summary": "example human prompt",
                "content": {
                    "role": "human",
                    "content": "Example AI-directed human prompt here, saying: Enjoy!",
                },
            }
        },
    },
    "functions": {
        "current": [],  # list of function names to send
        "options": {
            "example": {
                "description": "Example description of a function",
                "functioncode": "def describe(inputdata): return inputdata",
                "variables": {
                    "inputdata": {
                        "vartype": "str",
                        "default": "Hello"
                    }
                },
            }
        },
    },
    "functions_enabled": True,
    "function_call_results": {}
}

i = 0
while i < 10:
    send_prompt(settings)
    print('=' * 80)
    print(settings)
    print('^' * 80)
    i +=1