{"payload":{"feedbackUrl":"https://github.com/orgs/community/discussions/53140","repo":{"id":817089557,"defaultBranch":"main","name":"easyAGI","ownerLogin":"autoGLM","currentUserCanPush":false,"isFork":false,"isEmpty":false,"createdAt":"2024-06-19T02:13:11.000Z","ownerAvatar":"https://avatars.githubusercontent.com/u/167484117?v=4","public":true,"private":false,"isOrgOwned":true},"refInfo":{"name":"","listCacheKey":"v0:1718763197.902198","currentOid":""},"activityList":{"items":[{"before":"6e4f655d3a20a74a70ff07f662e044529125cb77","after":"6451b26268349db8c4fc8db548dac072fcb29d56","ref":"refs/heads/main","pushedAt":"2024-06-30T23:47:55.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update chatter.py\n\n# chatter.py\r\nimport openai\r\nfrom groq import Groq\r\nimport logging\r\n\r\nclass GPT4o:\r\n    def __init__(self, openai_api_key):\r\n        self.openai_api_key = openai_api_key\r\n        openai.api_key = self.openai_api_key\r\n\r\n    def generate_response(self, knowledge, model=\"gpt-4o\"):\r\n        prompt = f\"{knowledge}\"\r\n        try:\r\n            response = openai.chat.completions.create(\r\n                model=model,\r\n                messages=[\r\n                    {\"role\": \"system\", \"content\": \"\"},\r\n                    {\"role\": \"user\", \"content\": prompt}\r\n                ]\r\n            )\r\n            decision = response.choices[0].message.content\r\n            return decision.lower()\r\n        except openai.APIError as e:\r\n            logging.error(f\"openai api error: {e}\")\r\n            return \"error: unable to generate a response due to an issue with the openai api.\"\r\n\r\nclass GroqModel:\r\n    def __init__(self, groq_api_key):\r\n        self.client = Groq(api_key=groq_api_key)\r\n\r\n    def generate_response(self, knowledge, model=\"mixtral-8x7b-32768\"):\r\n        prompt = f\"{knowledge}\"\r\n        try:\r\n            chat_completion = self.client.chat.completions.create(\r\n                messages=[\r\n                    {\"role\": \"system\", \"content\": \"\"},\r\n                    {\"role\": \"user\", \"content\": prompt}\r\n                ],\r\n                model=model,\r\n            )\r\n            decision = chat_completion.choices[0].message.content\r\n            return decision.lower()\r\n        except Exception as e:\r\n            logging.error(f\"groq api error: {e}\")\r\n            return \"error: unable to generate a response due to an issue with the groq api.\"\r\n\r\nclass OllamaModel:\r\n    def __init__(self):\r\n        self.client = OpenAI(\r\n            base_url='http://localhost:11434/v1',\r\n            api_key='ollama',  # required, but unused\r\n        )\r\n\r\n    def generate_response(self, knowledge, model=\"llama2\"):\r\n        prompt = [\r\n            {\"role\": \"system\", \"content\": \"\"},\r\n            {\"role\": \"assistant\", \"content\": \"\"},\r\n            {\"role\": \"tool\", \"content\": \"\"},\r\n            {\"role\": \"user\", \"content\": f\"{knowledge}\"}\r\n        ]\r\n        try:\r\n            response = self.client.chat.completions.create(\r\n                model=model,\r\n                messages=prompt\r\n            )\r\n            decision = response.choices[0].message.content\r\n            return decision.lower()\r\n        except Exception as e:\r\n            logging.error(f\"ollama api error: {e}\")\r\n            return \"error: unable to generate a response due to an issue with the ollama api.\"","shortMessageHtmlLink":"Update chatter.py"}},{"before":"e2f2fcdb75af28d4b8bb89ed2409c18d18c3e860","after":"6e4f655d3a20a74a70ff07f662e044529125cb77","ref":"refs/heads/main","pushedAt":"2024-06-30T23:43:59.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update api.py\n\n# api.py\r\nimport os\r\nfrom dotenv import load_dotenv, set_key, unset_key, dotenv_values\r\n\r\nclass APIManager:\r\n    def __init__(self, env_file='.env'):\r\n        self.env_file = env_file\r\n        load_dotenv(self.env_file)\r\n        self.api_keys = self.load_api_keys()\r\n\r\n    def load_api_keys(self):\r\n        api_keys = {}\r\n        for key, value in dotenv_values(self.env_file).items():\r\n            if key.endswith('_API_KEY'):\r\n                api_keys[key] = value\r\n        return api_keys\r\n\r\n    def get_api_key(self, api_name):\r\n        key_name = f\"{api_name.upper()}_API_KEY\"\r\n        api_key = self.api_keys.get(key_name)\r\n        print(f\"DEBUG: Loaded API key for {api_name}: {api_key}\")  # Debug statement\r\n        return api_key\r\n\r\n    def add_api_key_interactive(self):\r\n        while True:\r\n            api_name = input(\"Enter API name (or press Enter to quit): \").strip()\r\n            if not api_name:\r\n                break\r\n            api_key = input(f\"Enter API key for {api_name}: \").strip()\r\n            if not api_key:\r\n                print(\"API key cannot be empty.\")\r\n                continue\r\n            key_name = f\"{api_name.upper()}_API_KEY\"\r\n            self.api_keys[key_name] = api_key\r\n            set_key(self.env_file, key_name, api_key)\r\n            print(f\"API key for {api_name} added.\")\r\n\r\n    def list_api_keys(self):\r\n        print(\"Loaded API keys:\")\r\n        for key in self.api_keys.keys():\r\n            api_name = key.replace('_API_KEY', '').lower()\r\n            print(f\"- {api_name}\")\r\n\r\n    def remove_api_key(self, api_name):\r\n        key_name = f\"{api_name.upper()}_API_KEY\"\r\n        if key_name in self.api_keys:\r\n            unset_key(self.env_file, key_name)\r\n            del self.api_keys[key_name]\r\n            print(f\"API key for {api_name} removed.\")\r\n        else:\r\n            print(f\"No API key found for {api_name}.\")\r\n\r\n# Usage example\r\nif __name__ == \"__main__\":\r\n    api_manager = APIManager()\r\n    openai_api_key = api_manager.get_api_key('openai')\r\n    if openai_api_key:\r\n        print(f\"OpenAI API key: {openai_api_key}\")\r\n    else:\r\n        print(\"OpenAI API key not found.\")","shortMessageHtmlLink":"Update api.py"}},{"before":"0d9592f0e4e284db3858bd7e674aa517f3f31761","after":"e2f2fcdb75af28d4b8bb89ed2409c18d18c3e860","ref":"refs/heads/main","pushedAt":"2024-06-30T23:36:48.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update easyAGI.py\n\n# easyAGI.py\r\nimport openai\r\nfrom api import APIManager\r\nfrom bdi import BDIModel, Belief, Desire, Intention\r\nfrom logic import LogicTables\r\nfrom SocraticReasoning import SocraticReasoning\r\nfrom reasoning import Reasoning\r\nfrom self_healing import SelfHealingSystem\r\nfrom memory import save_conversation_memory, load_conversation_memory, delete_conversation_memory\r\nfrom chatter import GPT4o, GroqModel, OllamaModel\r\n\r\nclass AGI:\r\n    def __init__(self):\r\n        # Initialize API Manager\r\n        self.api_manager = APIManager()\r\n        self.manage_api_keys()\r\n        \r\n        self.openai_api_key = self.api_manager.get_api_key('openai')\r\n        self.groq_api_key = self.api_manager.get_api_key('groq')\r\n        self.ollama_api_key = 'ollama'  # Ollama doesn't require an actual API key, just the identifier\r\n\r\n        if self.openai_api_key and self.groq_api_key and self.ollama_api_key:\r\n            self.chatter = self.select_provider()\r\n        elif self.openai_api_key:\r\n            print(f\"DEBUG: Using OpenAI API key: {self.openai_api_key}\")  # Debug statement\r\n            self.chatter = GPT4o(self.openai_api_key)\r\n        elif self.groq_api_key:\r\n            self.chatter = GroqModel(self.groq_api_key)\r\n        elif self.ollama_api_key:\r\n            self.chatter = OllamaModel()\r\n        else:\r\n            print(\"No API key found for OpenAI, Groq, or Ollama.\")\r\n            self.manage_api_keys()\r\n        \r\n        # Initialize other components\r\n        self.bdi_model = BDIModel()\r\n        self.logic_tables = LogicTables()\r\n        self.socratic_reasoner = SocraticReasoning(self.chatter)  # Pass the chatter instance\r\n        self.reasoner = Reasoning(self.chatter)  # Pass the chatter instance\r\n        self.self_healer = SelfHealingSystem()\r\n\r\n    def manage_api_keys(self):\r\n        while True:\r\n            self.api_manager.list_api_keys()\r\n            action = input(\"Choose an action: (a) Add API key, (d) Delete API key, (l) List API keys, (Press Enter to continue): \").strip().lower()\r\n            if not action:\r\n                self.openai_api_key = self.api_manager.get_api_key('openai')\r\n                self.groq_api_key = self.api_manager.get_api_key('groq')\r\n                self.ollama_api_key = 'ollama' if 'ollama' in self.api_manager.api_keys else None\r\n                if self.openai_api_key or self.groq_api_key or self.ollama_api_key:\r\n                    break\r\n                else:\r\n                    print(\"No API keys found. Please add at least one API key.\")\r\n            elif action == 'a':\r\n                self.api_manager.add_api_key_interactive()\r\n            elif action == 'd':\r\n                api_name = input(\"Enter the API name to delete: \").strip()\r\n                if api_name:\r\n                    self.api_manager.remove_api_key(api_name)\r\n            elif action == 'l':\r\n                self.api_manager.list_api_keys()\r\n\r\n    def select_provider(self):\r\n        while True:\r\n            choice = input(\"Multiple API keys found. Select the provider (1 for OpenAI, 2 for Groq, 3 for Ollama): \").strip()\r\n            if choice == '1':\r\n                return GPT4o(self.openai_api_key)\r\n            elif choice == '2':\r\n                return GroqModel(self.groq_api_key)\r\n            elif choice == '3':\r\n                return OllamaModel()\r\n            else:\r\n                print(\"Invalid choice. Please select 1 for OpenAI, 2 for Groq, or 3 for Ollama.\")\r\n\r\n    def perceive_environment(self):\r\n        # This method should gather data from the environment\r\n        agi_prompt = input(\"Enter the problem to solve (or type 'exit' to quit): \")\r\n        return agi_prompt\r\n    \r\n    def learn_from_data(self, data):\r\n        # This method should process and learn from the gathered data\r\n        new_belief = Belief(data, self.chatter)\r\n        self.bdi_model.update_beliefs({data: new_belief})\r\n        \r\n        new_desire = Desire(f\"Solve: {data}\")\r\n        self.bdi_model.set_desires([new_desire])\r\n        \r\n        self.bdi_model.form_intentions()\r\n        \r\n        self.logic_tables.add_variable('Belief')\r\n        self.logic_tables.add_expression('True')  # Simplified example\r\n        truth_table = self.logic_tables.generate_truth_table()\r\n        \r\n        # Display truth table\r\n        for row in truth_table:\r\n            print(\"\\t\".join(map(str, row)))\r\n        \r\n        self.socratic_reasoner.add_premise(data)\r\n        self.socratic_reasoner.draw_conclusion()\r\n\r\n        self.reasoner.add_premise(data)\r\n        self.reasoner.draw_conclusion()\r\n        \r\n        return data\r\n    \r\n    def make_decisions(self, knowledge):\r\n        # This method should make decisions based on the learned knowledge\r\n        decision = self.chatter.generate_response(knowledge)\r\n        return decision\r\n    \r\n    def communicate_response(self, decisions):\r\n        # This method should communicate the decision made\r\n        print(f\"\\nSolution:\\n{decisions}\\n\")\r\n    \r\n    def main_loop(self):\r\n        # Main loop to continuously perceive, learn, decide, and communicate\r\n        conversation_memory = []\r\n        while True:\r\n            environment_data = self.perceive_environment()\r\n            if environment_data.lower() == 'exit':\r\n                save_conversation_memory(conversation_memory)\r\n                break\r\n\r\n            learned_knowledge = self.learn_from_data(environment_data)\r\n            decisions = self.make_decisions(learned_knowledge)\r\n            self.communicate_response(decisions)\r\n\r\n            # Save the dialogue to memory\r\n            conversation_memory.append((environment_data, decisions))\r\n\r\ndef main():\r\n    agi = AGI()\r\n    agi.main_loop()\r\n    \r\nif __name__ == \"__main__\":\r\n    main()","shortMessageHtmlLink":"Update easyAGI.py"}},{"before":"582cbdd334a532070d1706ac2586f7f1dc990434","after":"0d9592f0e4e284db3858bd7e674aa517f3f31761","ref":"refs/heads/main","pushedAt":"2024-06-30T22:57:11.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Rename reasoner.py to reasoning.py\n\n# reasoning.py\r\nimport logging\r\nfrom chatter import GPT4o, GroqModel, OllamaModel\r\n\r\nclass Reasoning:\r\n    def __init__(self, chatter):\r\n        self.premises = []\r\n        self.logger = logging.getLogger('Reasoning')\r\n        self.logger.setLevel(logging.INFO)\r\n        self.max_tokens = 100\r\n        self.chatter = chatter\r\n\r\n    def log(self, message, level='info'):\r\n        if level == 'info':\r\n            self.logger.info(message)\r\n        elif level == 'error':\r\n            self.logger.error(message)\r\n        print(message)\r\n\r\n    def add_premise(self, premise):\r\n        self.premises.append(premise)\r\n        self.log(f'Added premise: {premise}')\r\n\r\n    def challenge_premise(self, premise):\r\n        if premise in self.premises:\r\n            self.premises.remove(premise)\r\n            self.log(f'Challenged and removed premise: {premise}')\r\n        else:\r\n            self.log(f'Premise not found: {premise}', level='error')\r\n\r\n    def draw_conclusion(self):\r\n        if not self.premises:\r\n            self.log('No premises available for logic as conclusion.', level='error')\r\n            return\r\n\r\n        premise_text = \"\\n\".join(f\"- {premise}\" for premise in self.premises)\r\n        prompt = f\"Based on the premises:\\n{premise_text}\\nProvide a logical conclusion.\"\r\n\r\n        # Use the appropriate model to generate the response\r\n        conclusion = self.chatter.generate_response(prompt)\r\n        self.log(f\"Conclusion:\\n{conclusion}\")\r\n\r\n    def set_max_tokens(self, max_tokens):\r\n        self.max_tokens = max_tokens\r\n        self.log(f\"Max tokens set to: {max_tokens}\")\r\n\r\n    def interact(self):\r\n        while True:\r\n            self.log(\"\\nCommands: add, challenge, conclude, set_tokens, exit\")\r\n            cmd = input(\"> \").strip().lower()\r\n            \r\n            if cmd == 'exit':\r\n                self.log('Exiting Reasoning.')\r\n                break\r\n            elif cmd == 'add':\r\n                premise = input(\"Enter the premise: \").strip()\r\n                self.add_premise(premise)\r\n            elif cmd == 'challenge':\r\n                premise = input(\"Enter the premise to challenge: \").strip()\r\n                self.challenge_premise(premise)\r\n            elif cmd == 'conclude':\r\n                self.draw_conclusion()\r\n            elif cmd == 'set_tokens':\r\n                tokens = input(\"Enter the maximum number of tokens for the conclusion: \").strip()\r\n                if tokens.isdigit():\r\n                    self.set_max_tokens(int(tokens))\r\n                else:\r\n                    self.log(\"Invalid number of tokens.\", level='error')\r\n            else:\r\n                self.log('Invalid command.', level='error')\r\n\r\ndef main():\r\n    # Replace 'your_api_key_here' with the actual API key or retrieve it as needed\r\n    api_key = 'your_api_key_here'\r\n    api_provider = 'openai'  # or 'groq' or 'ollama'\r\n    chatter = GPT4o(api_key)  # or GroqModel(api_key), OllamaModel()\r\n    reasoner = Reasoning(chatter)\r\n    reasoner.log('Reasoning initialized.')\r\n    reasoner.interact()\r\n\r\nif __name__ == '__main__':\r\n    main()","shortMessageHtmlLink":"Rename reasoner.py to reasoning.py"}},{"before":"0158b1bc902b0a725975ad54938262314caa102b","after":"582cbdd334a532070d1706ac2586f7f1dc990434","ref":"refs/heads/main","pushedAt":"2024-06-30T22:56:17.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Rename reasoning.py to reasoner.py\n\n# reasoning.py\r\nimport logging\r\nfrom chatter import GPT4o, GroqModel, OllamaModel\r\n\r\nclass Reasoning:\r\n    def __init__(self, chatter):\r\n        self.premises = []\r\n        self.logger = logging.getLogger('Reasoning')\r\n        self.logger.setLevel(logging.INFO)\r\n        self.max_tokens = 100\r\n        self.chatter = chatter\r\n\r\n    def log(self, message, level='info'):\r\n        if level == 'info':\r\n            self.logger.info(message)\r\n        elif level == 'error':\r\n            self.logger.error(message)\r\n        print(message)\r\n\r\n    def add_premise(self, premise):\r\n        self.premises.append(premise)\r\n        self.log(f'Added premise: {premise}')\r\n\r\n    def challenge_premise(self, premise):\r\n        if premise in self.premises:\r\n            self.premises.remove(premise)\r\n            self.log(f'Challenged and removed premise: {premise}')\r\n        else:\r\n            self.log(f'Premise not found: {premise}', level='error')\r\n\r\n    def draw_conclusion(self):\r\n        if not self.premises:\r\n            self.log('No premises available for logic as conclusion.', level='error')\r\n            return\r\n\r\n        premise_text = \"\\n\".join(f\"- {premise}\" for premise in self.premises)\r\n        prompt = f\"Based on the premises:\\n{premise_text}\\nProvide a logical conclusion.\"\r\n\r\n        # Use the appropriate model to generate the response\r\n        conclusion = self.chatter.generate_response(prompt)\r\n        self.log(f\"Conclusion:\\n{conclusion}\")\r\n\r\n    def set_max_tokens(self, max_tokens):\r\n        self.max_tokens = max_tokens\r\n        self.log(f\"Max tokens set to: {max_tokens}\")\r\n\r\n    def interact(self):\r\n        while True:\r\n            self.log(\"\\nCommands: add, challenge, conclude, set_tokens, exit\")\r\n            cmd = input(\"> \").strip().lower()\r\n            \r\n            if cmd == 'exit':\r\n                self.log('Exiting Reasoning.')\r\n                break\r\n            elif cmd == 'add':\r\n                premise = input(\"Enter the premise: \").strip()\r\n                self.add_premise(premise)\r\n            elif cmd == 'challenge':\r\n                premise = input(\"Enter the premise to challenge: \").strip()\r\n                self.challenge_premise(premise)\r\n            elif cmd == 'conclude':\r\n                self.draw_conclusion()\r\n            elif cmd == 'set_tokens':\r\n                tokens = input(\"Enter the maximum number of tokens for the conclusion: \").strip()\r\n                if tokens.isdigit():\r\n                    self.set_max_tokens(int(tokens))\r\n                else:\r\n                    self.log(\"Invalid number of tokens.\", level='error')\r\n            else:\r\n                self.log('Invalid command.', level='error')\r\n\r\ndef main():\r\n    # Replace 'your_api_key_here' with the actual API key or retrieve it as needed\r\n    api_key = 'your_api_key_here'\r\n    api_provider = 'openai'  # or 'groq' or 'ollama'\r\n    chatter = GPT4o(api_key)  # or GroqModel(api_key), OllamaModel()\r\n    reasoner = Reasoning(chatter)\r\n    reasoner.log('Reasoning initialized.')\r\n    reasoner.interact()\r\n\r\nif __name__ == '__main__':\r\n    main()","shortMessageHtmlLink":"Rename reasoning.py to reasoner.py"}},{"before":"900435d15276202826baca06f0181adea180c759","after":"0158b1bc902b0a725975ad54938262314caa102b","ref":"refs/heads/main","pushedAt":"2024-06-30T22:48:54.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Rename easyAGI.md to easyAGIcli.md\n\n# easyAGI.py\r\nimport openai\r\nfrom api import APIManager\r\nfrom bdi import BDIModel, Belief, Desire, Intention\r\nfrom logic import LogicTables\r\nfrom SocraticReasoning import SocraticReasoning\r\nfrom reasoning import Reasoning\r\nfrom self_healing import SelfHealingSystem\r\nfrom memory import save_conversation_memory, load_conversation_memory, delete_conversation_memory\r\nfrom chatter import GPT4o, GroqModel, OllamaModel\r\n\r\nclass AGI:\r\n    def __init__(self):\r\n        # Initialize API Manager\r\n        self.api_manager = APIManager()\r\n        self.manage_api_keys()\r\n        \r\n        self.openai_api_key = self.api_manager.get_api_key('openai')\r\n        self.groq_api_key = self.api_manager.get_api_key('groq')\r\n        self.ollama_api_key = 'ollama'  # Ollama doesn't require an actual API key, just the identifier\r\n\r\n        if self.openai_api_key and self.groq_api_key and self.ollama_api_key:\r\n            self.chatter = self.select_provider()\r\n        elif self.openai_api_key:\r\n            print(f\"DEBUG: Using OpenAI API key: {self.openai_api_key}\")  # Debug statement\r\n            self.chatter = GPT4o(self.openai_api_key)\r\n        elif self.groq_api_key:\r\n            self.chatter = GroqModel(self.groq_api_key)\r\n        elif self.ollama_api_key:\r\n            self.chatter = OllamaModel()\r\n        else:\r\n            print(\"No API key found for OpenAI, Groq, or Ollama.\")\r\n            self.manage_api_keys()\r\n        \r\n        # Initialize other components\r\n        self.bdi_model = BDIModel()\r\n        self.logic_tables = LogicTables()\r\n        self.socratic_reasoner = SocraticReasoning(self.chatter)  # Pass the chatter instance\r\n        self.reasoner = Reasoning(self.chatter)  # Pass the chatter instance\r\n        self.self_healer = SelfHealingSystem()\r\n\r\n    def manage_api_keys(self):\r\n        while True:\r\n            self.api_manager.list_api_keys()\r\n            action = input(\"Choose an action: (a) Add API key, (d) Delete API key, (l) List API keys, (Press Enter to continue): \").strip().lower()\r\n            if not action:\r\n                self.openai_api_key = self.api_manager.get_api_key('openai')\r\n                self.groq_api_key = self.api_manager.get_api_key('groq')\r\n                self.ollama_api_key = 'ollama' if 'ollama' in self.api_manager.api_keys else None\r\n                if self.openai_api_key or self.groq_api_key or self.ollama_api_key:\r\n                    break\r\n                else:\r\n                    print(\"No API keys found. Please add at least one API key.\")\r\n            elif action == 'a':\r\n                self.api_manager.add_api_key_interactive()\r\n            elif action == 'd':\r\n                api_name = input(\"Enter the API name to delete: \").strip()\r\n                if api_name:\r\n                    self.api_manager.remove_api_key(api_name)\r\n            elif action == 'l':\r\n                self.api_manager.list_api_keys()\r\n\r\n    def select_provider(self):\r\n        while True:\r\n            choice = input(\"Multiple API keys found. Select the provider (1 for OpenAI, 2 for Groq, 3 for Ollama): \").strip()\r\n            if choice == '1':\r\n                return GPT4o(self.openai_api_key)\r\n            elif choice == '2':\r\n                return GroqModel(self.groq_api_key)\r\n            elif choice == '3':\r\n                return OllamaModel()\r\n            else:\r\n                print(\"Invalid choice. Please select 1 for OpenAI, 2 for Groq, or 3 for Ollama.\")\r\n\r\n    def perceive_environment(self):\r\n        # This method should gather data from the environment\r\n        agi_prompt = input(\"Enter the problem to solve (or type 'exit' to quit): \")\r\n        return agi_prompt\r\n    \r\n    def learn_from_data(self, data):\r\n        # This method should process and learn from the gathered data\r\n        new_belief = Belief(data, self.chatter)\r\n        self.bdi_model.update_beliefs({data: new_belief})\r\n        \r\n        new_desire = Desire(f\"Solve: {data}\")\r\n        self.bdi_model.set_desires([new_desire])\r\n        \r\n        self.bdi_model.form_intentions()\r\n        \r\n        self.logic_tables.add_variable('Belief')\r\n        self.logic_tables.add_expression('True')  # Simplified example\r\n        truth_table = self.logic_tables.generate_truth_table()\r\n        \r\n        # Display truth table\r\n        for row in truth_table:\r\n            print(\"\\t\".join(map(str, row)))\r\n        \r\n        self.socratic_reasoner.add_premise(data)\r\n        self.socratic_reasoner.draw_conclusion()\r\n\r\n        self.reasoner.add_premise(data)\r\n        self.reasoner.draw_conclusion()\r\n        \r\n        return data\r\n    \r\n    def make_decisions(self, knowledge):\r\n        # This method should make decisions based on the learned knowledge\r\n        decision = self.chatter.generate_response(knowledge)\r\n        return decision\r\n    \r\n    def communicate_response(self, decisions):\r\n        # This method should communicate the decision made\r\n        print(f\"\\nSolution:\\n{decisions}\\n\")\r\n    \r\n    def main_loop(self):\r\n        # Main loop to continuously perceive, learn, decide, and communicate\r\n        conversation_memory = []\r\n        while True:\r\n            environment_data = self.perceive_environment()\r\n            if environment_data.lower() == 'exit':\r\n                save_conversation_memory(conversation_memory)\r\n                break\r\n\r\n            learned_knowledge = self.learn_from_data(environment_data)\r\n            decisions = self.make_decisions(learned_knowledge)\r\n            self.communicate_response(decisions)\r\n\r\n            # Save the dialogue to memory\r\n            conversation_memory.append((environment_data, decisions))\r\n\r\ndef main():\r\n    agi = AGI()\r\n    agi.main_loop()\r\n    \r\nif __name__ == \"__main__\":\r\n    main()","shortMessageHtmlLink":"Rename easyAGI.md to easyAGIcli.md"}},{"before":"f271661525e6fe678d350a35f13100034c923b88","after":"900435d15276202826baca06f0181adea180c759","ref":"refs/heads/main","pushedAt":"2024-06-30T22:48:26.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Create easyAGIcli.py\n\n# easyAGI.py\r\nimport openai\r\nfrom api import APIManager\r\nfrom bdi import BDIModel, Belief, Desire, Intention\r\nfrom logic import LogicTables\r\nfrom SocraticReasoning import SocraticReasoning\r\nfrom reasoning import Reasoning\r\nfrom self_healing import SelfHealingSystem\r\nfrom memory import save_conversation_memory, load_conversation_memory, delete_conversation_memory\r\nfrom chatter import GPT4o, GroqModel, OllamaModel\r\n\r\nclass AGI:\r\n    def __init__(self):\r\n        # Initialize API Manager\r\n        self.api_manager = APIManager()\r\n        self.manage_api_keys()\r\n        \r\n        self.openai_api_key = self.api_manager.get_api_key('openai')\r\n        self.groq_api_key = self.api_manager.get_api_key('groq')\r\n        self.ollama_api_key = 'ollama'  # Ollama doesn't require an actual API key, just the identifier\r\n\r\n        if self.openai_api_key and self.groq_api_key and self.ollama_api_key:\r\n            self.chatter = self.select_provider()\r\n        elif self.openai_api_key:\r\n            print(f\"DEBUG: Using OpenAI API key: {self.openai_api_key}\")  # Debug statement\r\n            self.chatter = GPT4o(self.openai_api_key)\r\n        elif self.groq_api_key:\r\n            self.chatter = GroqModel(self.groq_api_key)\r\n        elif self.ollama_api_key:\r\n            self.chatter = OllamaModel()\r\n        else:\r\n            print(\"No API key found for OpenAI, Groq, or Ollama.\")\r\n            self.manage_api_keys()\r\n        \r\n        # Initialize other components\r\n        self.bdi_model = BDIModel()\r\n        self.logic_tables = LogicTables()\r\n        self.socratic_reasoner = SocraticReasoning(self.chatter)  # Pass the chatter instance\r\n        self.reasoner = Reasoning(self.chatter)  # Pass the chatter instance\r\n        self.self_healer = SelfHealingSystem()\r\n\r\n    def manage_api_keys(self):\r\n        while True:\r\n            self.api_manager.list_api_keys()\r\n            action = input(\"Choose an action: (a) Add API key, (d) Delete API key, (l) List API keys, (Press Enter to continue): \").strip().lower()\r\n            if not action:\r\n                self.openai_api_key = self.api_manager.get_api_key('openai')\r\n                self.groq_api_key = self.api_manager.get_api_key('groq')\r\n                self.ollama_api_key = 'ollama' if 'ollama' in self.api_manager.api_keys else None\r\n                if self.openai_api_key or self.groq_api_key or self.ollama_api_key:\r\n                    break\r\n                else:\r\n                    print(\"No API keys found. Please add at least one API key.\")\r\n            elif action == 'a':\r\n                self.api_manager.add_api_key_interactive()\r\n            elif action == 'd':\r\n                api_name = input(\"Enter the API name to delete: \").strip()\r\n                if api_name:\r\n                    self.api_manager.remove_api_key(api_name)\r\n            elif action == 'l':\r\n                self.api_manager.list_api_keys()\r\n\r\n    def select_provider(self):\r\n        while True:\r\n            choice = input(\"Multiple API keys found. Select the provider (1 for OpenAI, 2 for Groq, 3 for Ollama): \").strip()\r\n            if choice == '1':\r\n                return GPT4o(self.openai_api_key)\r\n            elif choice == '2':\r\n                return GroqModel(self.groq_api_key)\r\n            elif choice == '3':\r\n                return OllamaModel()\r\n            else:\r\n                print(\"Invalid choice. Please select 1 for OpenAI, 2 for Groq, or 3 for Ollama.\")\r\n\r\n    def perceive_environment(self):\r\n        # This method should gather data from the environment\r\n        agi_prompt = input(\"Enter the problem to solve (or type 'exit' to quit): \")\r\n        return agi_prompt\r\n    \r\n    def learn_from_data(self, data):\r\n        # This method should process and learn from the gathered data\r\n        new_belief = Belief(data, self.chatter)\r\n        self.bdi_model.update_beliefs({data: new_belief})\r\n        \r\n        new_desire = Desire(f\"Solve: {data}\")\r\n        self.bdi_model.set_desires([new_desire])\r\n        \r\n        self.bdi_model.form_intentions()\r\n        \r\n        self.logic_tables.add_variable('Belief')\r\n        self.logic_tables.add_expression('True')  # Simplified example\r\n        truth_table = self.logic_tables.generate_truth_table()\r\n        \r\n        # Display truth table\r\n        for row in truth_table:\r\n            print(\"\\t\".join(map(str, row)))\r\n        \r\n        self.socratic_reasoner.add_premise(data)\r\n        self.socratic_reasoner.draw_conclusion()\r\n\r\n        self.reasoner.add_premise(data)\r\n        self.reasoner.draw_conclusion()\r\n        \r\n        return data\r\n    \r\n    def make_decisions(self, knowledge):\r\n        # This method should make decisions based on the learned knowledge\r\n        decision = self.chatter.generate_response(knowledge)\r\n        return decision\r\n    \r\n    def communicate_response(self, decisions):\r\n        # This method should communicate the decision made\r\n        print(f\"\\nSolution:\\n{decisions}\\n\")\r\n    \r\n    def main_loop(self):\r\n        # Main loop to continuously perceive, learn, decide, and communicate\r\n        conversation_memory = []\r\n        while True:\r\n            environment_data = self.perceive_environment()\r\n            if environment_data.lower() == 'exit':\r\n                save_conversation_memory(conversation_memory)\r\n                break\r\n\r\n            learned_knowledge = self.learn_from_data(environment_data)\r\n            decisions = self.make_decisions(learned_knowledge)\r\n            self.communicate_response(decisions)\r\n\r\n            # Save the dialogue to memory\r\n            conversation_memory.append((environment_data, decisions))\r\n\r\ndef main():\r\n    agi = AGI()\r\n    agi.main_loop()\r\n    \r\nif __name__ == \"__main__\":\r\n    main()","shortMessageHtmlLink":"Create easyAGIcli.py"}},{"before":"66b6fcfde3a66277173ec0366f5beb7d9709de77","after":"f271661525e6fe678d350a35f13100034c923b88","ref":"refs/heads/main","pushedAt":"2024-06-30T22:47:12.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update easyAGI.py\n\n# easyAGI (c) Gregory L. Magnusson MIT license 2024 \r\nfrom nicegui import ui, app\r\nimport openai\r\nimport logging\r\nimport asyncio\r\nimport concurrent.futures\r\nfrom memory import create_memory_folders, store_in_stm, DialogEntry\r\nfrom agi import AGI\r\nfrom api import APIManager\r\nfrom chatter import GPT4o, GroqModel\r\nfrom fastapi.staticfiles import StaticFiles\r\nimport os\r\n\r\n# Set up logging\r\nlogging.basicConfig(level=logging.DEBUG)\r\n\r\n# Serve static files from the 'gfx' directory\r\napp.mount('/gfx', StaticFiles(directory='gfx'), name='gfx')\r\n\r\n# Serve the CSS file\r\napp.mount('/static', StaticFiles(directory='static'), name='static')\r\n\r\nclass FundamentalAGI:\r\n    def __init__(self):\r\n        self.api_manager = APIManager()\r\n        self.agi = None\r\n        self.initialize_memory()\r\n        self.initialize_agi()\r\n\r\n    def initialize_memory(self):\r\n        create_memory_folders()\r\n\r\n    def add_api_key(self):\r\n        service = self.service_input.value.strip()\r\n        api_key = self.key_input.value.strip()\r\n        logging.debug(f\"Adding API key for {service}: {api_key[:4]}...{api_key[-4:]}\")\r\n        if service and api_key:\r\n            self.api_manager.api_keys[service] = api_key\r\n            self.api_manager.save_api_key(service, api_key)\r\n            self.initialize_agi()\r\n            ui.notify(f'API key for {service} added and loaded successfully')\r\n            self.service_input.value = ''\r\n            self.key_input.value = ''\r\n            ui.run_javascript('setTimeout(() => { window.location.href = \"/\"; }, 1000);')\r\n        else:\r\n            ui.notify('Please provide both service name and API key')\r\n\r\n    def delete_api_key(self, service):\r\n        logging.debug(f\"Deleting API key for {service}\")\r\n        if service in self.api_manager.api_keys:\r\n            del self.api_manager.api_keys[service]\r\n            self.api_manager.remove_api_key(service)\r\n            self.initialize_agi()\r\n            ui.notify(f'API key for {service} removed successfully')\r\n            self.list_api_keys()  # Refresh the list after deletion\r\n        else:\r\n            ui.notify(f'No API key found for {service}')\r\n\r\n    def list_api_keys(self):\r\n        if self.api_manager.api_keys:\r\n            keys_list = [(service, key) for service, key in self.api_manager.api_keys.items()]\r\n            logging.debug(f\"Stored API keys: {keys_list}\")\r\n            keys_container.clear()\r\n            for service, key in keys_list:\r\n                with keys_container:\r\n                    ui.label(f\"{service}: {key[:4]}...{key[-4:]}\").classes('flex-1')\r\n                    ui.button('Delete', on_click=lambda s=service: self.delete_api_key(s)).classes('ml-4')\r\n            ui.notify('Stored API keys:\\n' + \"\\n\".join([f\"{service}: {key[:4]}...{key[-4:]}\" for service, key in keys_list]))\r\n        else:\r\n            ui.notify('No API keys in storage')\r\n            keys_container.clear()\r\n            with keys_container:\r\n                ui.label('No API keys in storage')\r\n\r\n    def initialize_agi(self):\r\n        openai_key = self.api_manager.get_api_key('openai')\r\n        groq_key = self.api_manager.get_api_key('groq')\r\n        \r\n        if openai_key:\r\n            chatter = GPT4o(openai_key)\r\n        elif groq_key:\r\n            chatter = GroqModel(groq_key)\r\n        else:\r\n            self.agi = None\r\n            ui.notify(\"Please add an OpenAI or Groq API key.\")\r\n            return\r\n        \r\n        self.agi = AGI(chatter)\r\n        logging.debug(\"AGI initialized\")\r\n\r\n    def get_conclusion_from_agi(self, prompt):\r\n        if self.agi is None:\r\n            ui.notify(\"Please initialize AGI with an API key first.\")\r\n            return \"AGI not initialized.\"\r\n        self.agi.reasoning.add_premise(prompt)\r\n        conclusion = self.agi.reasoning.draw_conclusion()\r\n        return conclusion\r\n\r\n    def perceive_environment(self, agi_prompt):\r\n        return agi_prompt\r\n\r\n    def communicate_response(self, conclusion):\r\n        logging.info(f\"Communicating response: {conclusion}\")\r\n        return conclusion\r\n\r\n    def read_log_file(self, file_path):\r\n        if os.path.exists(file_path):\r\n            with open(file_path, 'r') as file:\r\n                return file.read()\r\n        else:\r\n            return f\"Log file {file_path} does not exist.\"\r\n\r\nfundamental_agi = FundamentalAGI()\r\n\r\n@ui.page('/')\r\ndef main():\r\n    executor = concurrent.futures.ThreadPoolExecutor()\r\n\r\n    async def send() -> None:\r\n        question = text.value\r\n        text.value = ''\r\n        with message_container:\r\n            ui.chat_message(text=question, name='query', sent=True)\r\n            response_message = ui.chat_message(name='funAGI', sent=False)\r\n            spinner = ui.spinner(type='dots')\r\n\r\n        try:\r\n            loop = asyncio.get_event_loop()\r\n            conclusion = await loop.run_in_executor(executor, fundamental_agi.get_conclusion_from_agi, question)\r\n            response_message.clear()\r\n            with response_message:\r\n                ui.html(conclusion)\r\n            await ui.run_javascript('window.scrollTo(0, document.body.scrollHeight)', timeout=5.0)\r\n\r\n            # Store the dialog entry\r\n            entry = DialogEntry(question, conclusion)\r\n            store_in_stm(entry)\r\n        except Exception as e:\r\n            logging.error(f\"Error getting conclusion from funAGI: {e}\")\r\n            log.push(f\"Error getting conclusion from funAGI: {e}\")\r\n        finally:\r\n            message_container.remove(spinner)  # Correctly remove the spinner\r\n\r\n    # Link the external stylesheet\r\n    ui.add_head_html('<link rel=\"stylesheet\" href=\"/static/style.css\">')\r\n\r\n    # Initialize dark mode toggle\r\n    dark_mode = ui.dark_mode()\r\n\r\n    async def toggle_dark_mode():\r\n        dark_mode.value = not dark_mode.value\r\n        dark_mode_toggle.text = 'Light Mode' if dark_mode.value else 'Dark Mode'\r\n\r\n    with ui.row().classes('justify-end w-full p-4'):\r\n        dark_mode_toggle = ui.button('Dark Mode', on_click=toggle_dark_mode)\r\n        # Adding log file buttons\r\n        log_files = {\r\n            \"Premises Log\": \"./memory/logs/premises.json\",\r\n            \"Not Premise Log\": \"./memory/logs/notpremise.json\",\r\n            \"Conclusions Log\": \"./memory/logs/conclusions.txt\",\r\n            \"Truth Tables Log\": \"./memory/logs/truth_tables.json\",\r\n            \"Decisions Log\": \"./memory/logs/decisions.json\"\r\n        }\r\n\r\n        for log_name, log_path in log_files.items():\r\n            ui.button(log_name, on_click=lambda path=log_path: view_log(path)).classes('ml-2')\r\n\r\n    # Function to view log files\r\n    def view_log(file_path):\r\n        log_content = fundamental_agi.read_log_file(file_path)\r\n        log_container.clear()  # Clear the existing log content\r\n        with log_container:\r\n            ui.markdown(log_content).classes('w-full')\r\n\r\n    with ui.tabs().classes('w-full') as tabs:\r\n        chat_tab = ui.tab('chat')\r\n        logs_tab = ui.tab('logs')\r\n        api_tab = ui.tab('API Keys')\r\n    with ui.tab_panels(tabs, value=chat_tab).classes('w-full max-w-2xl mx-auto flex-grow items-stretch'):\r\n        message_container = ui.tab_panel(chat_tab).classes('items-stretch')\r\n        with ui.tab_panel(logs_tab):\r\n            log = ui.log().classes('w-full h-full')\r\n            log_container = ui.column().classes('w-full')\r\n        with ui.tab_panel(api_tab):\r\n            ui.label('Manage API Keys').classes('text-lg font-bold')\r\n            with ui.row().classes('items-center'):\r\n                fundamental_agi.service_input = ui.input('Service (e.g., \"openai\", \"groq\")').classes('flex-1')\r\n                fundamental_agi.key_input = ui.input('API Key').classes('flex-1')\r\n            with ui.dropdown_button('Actions', auto_close=True):\r\n                ui.menu_item('Add API Key', on_click=fundamental_agi.add_api_key)\r\n                ui.menu_item('List API Keys', on_click=fundamental_agi.list_api_keys)\r\n\r\n            # Container to list keys with delete buttons\r\n            global keys_container\r\n            keys_container = ui.column().classes('w-full')\r\n\r\n    with ui.footer().classes('bg-white'), ui.column().classes('w-full max-w-3xl mx-auto my-6 input-area'):\r\n        with ui.row().classes('w-full no-wrap items-center'):\r\n            placeholder = 'Enter your prompt here'\r\n            text = ui.input(placeholder=placeholder).props('rounded outlined input-class=mx-3') \\\r\n                .classes('w-full self-center').on('keydown.enter', send)\r\n        ui.markdown('[funAGI](https://github.com/autoGLM/funAGI)').classes('text-xs self-end mr-8 m-[-1em] text-primary')\r\n\r\nlogging.debug(\"starting funAGI\")\r\nui.run(title='funAGI')\r\n\r\nif __name__ == '__main__':\r\n    main()","shortMessageHtmlLink":"Update easyAGI.py"}},{"before":"75510185b1c3d0eea6efc88109724fdcc5ad2755","after":"66b6fcfde3a66277173ec0366f5beb7d9709de77","ref":"refs/heads/main","pushedAt":"2024-06-30T22:42:38.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\n<a href=\"https://github.com/autoGLM/funAGI\">https://github.com/autoGLM/funAGI</a>","shortMessageHtmlLink":"Update README.md"}},{"before":"52b0979c9f9434f758379b2d6fb2edd1b0491110","after":"75510185b1c3d0eea6efc88109724fdcc5ad2755","ref":"refs/heads/main","pushedAt":"2024-06-30T22:40:33.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Add files via upload\n\nupdate to reasoning from logic","shortMessageHtmlLink":"Add files via upload"}},{"before":"499f0c39e4a71c7fb655d6ab4a99e38c78cbb1a1","after":"52b0979c9f9434f758379b2d6fb2edd1b0491110","ref":"refs/heads/main","pushedAt":"2024-06-26T00:23:08.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nfunAGI is the current working expression\r\n<a href=\"https://github.com/autoGLM/funAGI\">https://github.com/autoGLM/funAGI</a>","shortMessageHtmlLink":"Update README.md"}},{"before":"e4f0b4002d76a53e111a299e71e725639488bc5a","after":"499f0c39e4a71c7fb655d6ab4a99e38c78cbb1a1","ref":"refs/heads/main","pushedAt":"2024-06-26T00:22:24.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nfunAGI is the current working expression\r\n<a href=\"https://github.com/autoGLM/funAGI\">https://github.com/autoGLM/funAGI</a>","shortMessageHtmlLink":"Update README.md"}},{"before":"472c2bcc6c8b93704912abf4f9d647862e9e61bf","after":"e4f0b4002d76a53e111a299e71e725639488bc5a","ref":"refs/heads/main","pushedAt":"2024-06-22T20:28:36.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nhttps://github.com/autoGLM/easyAGI","shortMessageHtmlLink":"Update README.md"}},{"before":"baee49994efddddb258ee3774ff14cdd979d86c6","after":"472c2bcc6c8b93704912abf4f9d647862e9e61bf","ref":"refs/heads/main","pushedAt":"2024-06-20T00:59:22.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md","shortMessageHtmlLink":"Update README.md"}},{"before":"aad05f983f86b0eac106d8a05caced6d407263d0","after":"baee49994efddddb258ee3774ff14cdd979d86c6","ref":"refs/heads/main","pushedAt":"2024-06-20T00:58:40.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nFor the most minimalist python3 approach to GPT-4o API interactive example see <a href=\"https://github.com/openmindx/agi\">agi</a>","shortMessageHtmlLink":"Update README.md"}},{"before":"6369cafccd54195e8347bacbca6bc6df05e7164a","after":"aad05f983f86b0eac106d8a05caced6d407263d0","ref":"refs/heads/main","pushedAt":"2024-06-20T00:58:11.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nFor the most minimalist python3 approach to GPT-4o API interactive example see <a href=\"https://github.com/openmindx/agi\">agi</a>","shortMessageHtmlLink":"Update README.md"}},{"before":"88cc002a0e7eb1affbd14acf81256e995c83f7fb","after":"6369cafccd54195e8347bacbca6bc6df05e7164a","ref":"refs/heads/main","pushedAt":"2024-06-20T00:55:22.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nimport jax.numpy as jnp\r\nimport jax.random as random\r\nimport optax\r\nimport haiku as hk\r\n\r\nclass SimpleMind:\r\n    def __init__(self, input_size, hidden_sizes, output_size, activation='relu', optimizer='adam'):\r\n        \"\"\"\r\n        Initialize the SimpleMind neural network.\r\n        \r\n        :param input_size: Size of the input layer.\r\n        :param hidden_sizes: List of sizes for hidden layers.\r\n        :param output_size: Size of the output layer.\r\n        :param activation: Activation function to use ('relu' or 'sigmoid').\r\n        :param optimizer: Optimizer to use ('adam' or 'sgd').\r\n        \"\"\"\r\n        self.input_size = input_size\r\n        self.hidden_sizes = hidden_sizes\r\n        self.output_size = output_size\r\n        self.activation = activation\r\n        self.optimizer = optimizer\r\n        self.rng = random.PRNGKey(0)\r\n        self.params = self._initialize_parameters()\r\n        self.opt_state = self._initialize_optimizer()\r\n\r\n    def _initialize_parameters(self):\r\n        \"\"\"\r\n        Initialize the parameters of the network.\r\n        \r\n        :return: Dictionary of initialized parameters.\r\n        \"\"\"\r\n        layer_sizes = [self.input_size] + self.hidden_sizes + [self.output_size]\r\n        params = {}\r\n        for i in range(len(layer_sizes) - 1):\r\n            self.rng, layer_rng = random.split(self.rng)\r\n            params[f'W{i}'] = random.normal(layer_rng, (layer_sizes[i], layer_sizes[i+1])) * 0.01\r\n            params[f'b{i}'] = jnp.zeros(layer_sizes[i+1])\r\n        return params\r\n\r\n    def _initialize_optimizer(self):\r\n        \"\"\"\r\n        Initialize the optimizer state.\r\n        \r\n        :return: Initialized optimizer state.\r\n        \"\"\"\r\n        if self.optimizer == 'adam':\r\n            optimizer = optax.adam(1e-3)\r\n        elif self.optimizer == 'sgd':\r\n            optimizer = optax.sgd(1e-3)\r\n        else:\r\n            raise ValueError(f\"Unsupported optimizer: {self.optimizer}\")\r\n        return optimizer.init(self.params)\r\n\r\n    def forward(self, X):\r\n        \"\"\"\r\n        Perform a forward pass through the network.\r\n        \r\n        :param X: Input data.\r\n        :return: Output of the network.\r\n        \"\"\"\r\n        out = X\r\n        for i in range(len(self.hidden_sizes)):\r\n            W, b = self.params[f'W{i}'], self.params[f'b{i}']\r\n            out = jnp.dot(out, W) + b\r\n            if self.activation == 'relu':\r\n                out = jnp.maximum(0, out)\r\n            elif self.activation == 'sigmoid':\r\n                out = 1 / (1 + jnp.exp(-out))\r\n            else:\r\n                raise ValueError(f\"Unsupported activation: {self.activation}\")\r\n        W, b = self.params[f'W{len(self.hidden_sizes)}'], self.params[f'b{len(self.hidden_sizes)}']\r\n        out = jnp.dot(out, W) + b\r\n        return out\r\n\r\n    def update_parameters(self, grads):\r\n        \"\"\"\r\n        Update the parameters of the network.\r\n        \r\n        :param grads: Gradients for the parameters.\r\n        \"\"\"\r\n        updates, self.opt_state = optax.adam(1e-3).update(grads, self.opt_state)\r\n        self.params = optax.apply_updates(self.params, updates)\r\n\r\n    def train(self, X, y):\r\n        \"\"\"\r\n        Train the network on the given data.\r\n        \r\n        :param X: Input data.\r\n        :param y: Target labels.\r\n        \"\"\"\r\n        def loss(params, X, y):\r\n            predictions = self.forward(X)\r\n            return jnp.mean((predictions - y) ** 2)\r\n        \r\n        grads = jax.grad(loss)(self.params, X, y)\r\n        self.update_parameters(grads)\r\n\r\n# Example usage:\r\nif __name__ == \"__main__\":\r\n    simple_mind = SimpleMind(input_size=4, hidden_sizes=[10, 10], output_size=1, activation='relu', optimizer='adam')\r\n    X = jnp.array([[1.0, 2.0, 3.0, 4.0]])\r\n    y = jnp.array([[1.0]])\r\n    simple_mind.train(X, y)\r\n    print(simple_mind.forward(X))","shortMessageHtmlLink":"Update README.md"}},{"before":"9a47e26134017b6b7c030f3e9aeb3b29d6368cd4","after":"88cc002a0e7eb1affbd14acf81256e995c83f7fb","ref":"refs/heads/main","pushedAt":"2024-06-19T23:27:15.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Create agi.py\n\nimport numpy as np\r\nimport logging\r\nfrom jax import numpy as jnp\r\nimport jax\r\nfrom jax import grad, jit, vmap, pmap\r\nfrom typing import List, Tuple, Union\r\nfrom concurrent.futures import ThreadPoolExecutor, as_completed\r\nimport optax  # For advanced optimization algorithms\r\nimport haiku as hk  # For model building and parameter management\r\n\r\nclass SimpleMind:\r\n    def __init__(self, input_size, hidden_sizes, output_size, activation='relu', optimizer='adam', learning_rate=0.001, regularization=None, reg_lambda=0.01):\r\n        \"\"\"\r\n        Initialize the SimpleMind neural network.\r\n        \r\n        :param input_size: Number of input neurons.\r\n        :param hidden_sizes: List of the number of neurons in each hidden layer.\r\n        :param output_size: Number of output neurons.\r\n        :param activation: Activation function to use ('sigmoid', 'tanh', 'relu').\r\n        :param optimizer: Optimizer to use ('sgd', 'adam').\r\n        :param learning_rate: Learning rate for training.\r\n        :param regularization: Regularization method ('l2').\r\n        :param reg_lambda: Regularization strength.\r\n        \"\"\"\r\n        self.input_size = input_size\r\n        self.hidden_sizes = hidden_sizes\r\n        self.output_size = output_size\r\n        self.learning_rate = learning_rate\r\n        self.regularization = regularization\r\n        self.reg_lambda = reg_lambda\r\n\r\n        self.params = self._initialize_parameters()\r\n\r\n        self.activation = activation\r\n        self.optimizer = optimizer\r\n        self.opt_state = self._setup_optimizer()\r\n        self._setup_logging()\r\n\r\n    def _setup_logging(self):\r\n        logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\r\n\r\n    def _activation_function(self, s):\r\n        if self.activation == 'sigmoid':\r\n            return 1 / (1 + jnp.exp(-s))\r\n        elif self.activation == 'tanh':\r\n            return jnp.tanh(s)\r\n        elif self.activation == 'relu':\r\n            return jnp.maximum(0, s)\r\n        else:\r\n            raise ValueError(\"Unsupported activation function.\")\r\n\r\n    def _activation_derivative(self, s):\r\n        if self.activation == 'sigmoid':\r\n            return s * (1 - s)\r\n        elif self.activation == 'tanh':\r\n            return 1 - jnp.power(s, 2)\r\n        elif self.activation == 'relu':\r\n            return jnp.where(s > 0, 1, 0)\r\n        else:\r\n            raise ValueError(\"Unsupported activation function.\")\r\n\r\n    def _initialize_parameters(self):\r\n        params = {}\r\n        layer_sizes = [self.input_size] + self.hidden_sizes + [self.output_size]\r\n        for i in range(len(layer_sizes) - 1):\r\n            params[f'W{i}'] = jnp.random.randn(layer_sizes[i], layer_sizes[i+1]) * 0.01\r\n            params[f'b{i}'] = jnp.zeros(layer_sizes[i+1])\r\n        return params\r\n\r\n    def forward(self, X, params):\r\n        activations = X\r\n        for i in range(len(self.hidden_sizes) + 1):\r\n            z = jnp.dot(activations, params[f'W{i}']) + params[f'b{i}']\r\n            activations = self._activation_function(z) if i < len(self.hidden_sizes) else z\r\n        return activations\r\n\r\n    @jit\r\n    def backpropagate(self, X, y, params, opt_state):\r\n        def loss_fn(params):\r\n            predictions = self.forward(X, params)\r\n            loss = jnp.mean(jnp.square(y - predictions))\r\n            if self.regularization == 'l2':\r\n                l2_penalty = sum(jnp.sum(jnp.square(params[f'W{i}'])) for i in range(len(self.hidden_sizes) + 1))\r\n                loss += self.reg_lambda * l2_penalty / 2\r\n            return loss\r\n\r\n        grads = grad(loss_fn)(params)\r\n        updates, opt_state = self.optimizer.update(grads, opt_state)\r\n        new_params = optax.apply_updates(params, updates)\r\n        return new_params, opt_state\r\n\r\n    def _setup_optimizer(self):\r\n        if self.optimizer == 'adam':\r\n            self.optimizer = optax.adam(self.learning_rate)\r\n        elif self.optimizer == 'sgd':\r\n            self.optimizer = optax.sgd(self.learning_rate)\r\n        else:\r\n            raise ValueError(\"Unsupported optimizer.\")\r\n        return self.optimizer.init(self.params)\r\n\r\n    def train(self, X, y, epochs):\r\n        for epoch in range(epochs):\r\n            self.params, self.opt_state = self._parallel_backpropagate(X, y, self.params, self.opt_state)\r\n            if epoch % 100 == 0:\r\n                loss = self._calculate_loss(X, y, self.params)\r\n                logging.info(f\"Epoch {epoch}, Loss: {loss}\")\r\n\r\n    def _parallel_backpropagate(self, X, y, params, opt_state):\r\n        with ThreadPoolExecutor() as executor:\r\n            futures = [executor.submit(self.backpropagate, X[i], y[i], params, opt_state) for i in range(len(X))]\r\n            for future in as_completed(futures):\r\n                params, opt_state = future.result()\r\n        return params, opt_state\r\n\r\n    @jit\r\n    def _calculate_loss(self, X, y, params):\r\n        output = self.forward(X, params)\r\n        loss = jnp.mean(jnp.square(y - output))\r\n        if self.regularization == 'l2':\r\n            loss += self.reg_lambda / 2 * sum(jnp.sum(jnp.square(params[f'W{i}'])) for i in range(len(self.hidden_sizes) + 1))\r\n        return loss\r\n\r\n# Example Usage\r\nif __name__ == \"__main__\":\r\n    input_size = 3\r\n    hidden_sizes = [5, 5]\r\n    output_size = 1\r\n    learning_rate = 0.001\r\n    epochs = 1000\r\n\r\n    X = jnp.array([[0.1, 0.2, 0.3]])\r\n    y = jnp.array([[0.5]])\r\n\r\n    mind = SimpleMind(input_size, hidden_sizes, output_size, activation='relu', optimizer='adam', learning_rate=learning_rate, regularization='l2', reg_lambda=0.01)\r\n\r\n    mind.train(X, y, epochs)\r\n    print(\"Final Output:\", mind.forward(X, mind.params))","shortMessageHtmlLink":"Create agi.py"}},{"before":"bbfa90f20a86248e87720c8cb6649d0c98b726ca","after":"9a47e26134017b6b7c030f3e9aeb3b29d6368cd4","ref":"refs/heads/main","pushedAt":"2024-06-19T23:25:01.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Create SimpleMind.py\n\nimport numpy as np\r\nimport logging\r\nfrom jax import numpy as jnp\r\nimport jax\r\nfrom jax import grad, jit, vmap, pmap\r\nfrom typing import List, Tuple, Union\r\nfrom concurrent.futures import ThreadPoolExecutor, as_completed\r\nimport optax  # For advanced optimization algorithms\r\nimport haiku as hk  # For model building and parameter management\r\n\r\nclass SimpleMind:\r\n    def __init__(self, input_size, hidden_sizes, output_size, activation='relu', optimizer='adam', learning_rate=0.001, regularization=None, reg_lambda=0.01):\r\n        \"\"\"\r\n        Initialize the SimpleMind neural network.\r\n        \r\n        :param input_size: Number of input neurons.\r\n        :param hidden_sizes: List of the number of neurons in each hidden layer.\r\n        :param output_size: Number of output neurons.\r\n        :param activation: Activation function to use ('sigmoid', 'tanh', 'relu').\r\n        :param optimizer: Optimizer to use ('sgd', 'adam').\r\n        :param learning_rate: Learning rate for training.\r\n        :param regularization: Regularization method ('l2').\r\n        :param reg_lambda: Regularization strength.\r\n        \"\"\"\r\n        self.input_size = input_size\r\n        self.hidden_sizes = hidden_sizes\r\n        self.output_size = output_size\r\n        self.learning_rate = learning_rate\r\n        self.regularization = regularization\r\n        self.reg_lambda = reg_lambda\r\n\r\n        self.params = self._initialize_parameters()\r\n\r\n        self.activation = activation\r\n        self.optimizer = optimizer\r\n        self.opt_state = self._setup_optimizer()\r\n        self._setup_logging()\r\n\r\n    def _setup_logging(self):\r\n        logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\r\n\r\n    def _activation_function(self, s):\r\n        if self.activation == 'sigmoid':\r\n            return 1 / (1 + jnp.exp(-s))\r\n        elif self.activation == 'tanh':\r\n            return jnp.tanh(s)\r\n        elif self.activation == 'relu':\r\n            return jnp.maximum(0, s)\r\n        else:\r\n            raise ValueError(\"Unsupported activation function.\")\r\n\r\n    def _activation_derivative(self, s):\r\n        if self.activation == 'sigmoid':\r\n            return s * (1 - s)\r\n        elif self.activation == 'tanh':\r\n            return 1 - jnp.power(s, 2)\r\n        elif self.activation == 'relu':\r\n            return jnp.where(s > 0, 1, 0)\r\n        else:\r\n            raise ValueError(\"Unsupported activation function.\")\r\n\r\n    def _initialize_parameters(self):\r\n        params = {}\r\n        layer_sizes = [self.input_size] + self.hidden_sizes + [self.output_size]\r\n        for i in range(len(layer_sizes) - 1):\r\n            params[f'W{i}'] = jnp.random.randn(layer_sizes[i], layer_sizes[i+1]) * 0.01\r\n            params[f'b{i}'] = jnp.zeros(layer_sizes[i+1])\r\n        return params\r\n\r\n    def forward(self, X, params):\r\n        activations = X\r\n        for i in range(len(self.hidden_sizes) + 1):\r\n            z = jnp.dot(activations, params[f'W{i}']) + params[f'b{i}']\r\n            activations = self._activation_function(z) if i < len(self.hidden_sizes) else z\r\n        return activations\r\n\r\n    @jit\r\n    def backpropagate(self, X, y, params, opt_state):\r\n        def loss_fn(params):\r\n            predictions = self.forward(X, params)\r\n            loss = jnp.mean(jnp.square(y - predictions))\r\n            if self.regularization == 'l2':\r\n                l2_penalty = sum(jnp.sum(jnp.square(params[f'W{i}'])) for i in range(len(self.hidden_sizes) + 1))\r\n                loss += self.reg_lambda * l2_penalty / 2\r\n            return loss\r\n\r\n        grads = grad(loss_fn)(params)\r\n        updates, opt_state = self.optimizer.update(grads, opt_state)\r\n        new_params = optax.apply_updates(params, updates)\r\n        return new_params, opt_state\r\n\r\n    def _setup_optimizer(self):\r\n        if self.optimizer == 'adam':\r\n            self.optimizer = optax.adam(self.learning_rate)\r\n        elif self.optimizer == 'sgd':\r\n            self.optimizer = optax.sgd(self.learning_rate)\r\n        else:\r\n            raise ValueError(\"Unsupported optimizer.\")\r\n        return self.optimizer.init(self.params)\r\n\r\n    def train(self, X, y, epochs):\r\n        for epoch in range(epochs):\r\n            self.params, self.opt_state = self._parallel_backpropagate(X, y, self.params, self.opt_state)\r\n            if epoch % 100 == 0:\r\n                loss = self._calculate_loss(X, y, self.params)\r\n                logging.info(f\"Epoch {epoch}, Loss: {loss}\")\r\n\r\n    def _parallel_backpropagate(self, X, y, params, opt_state):\r\n        with ThreadPoolExecutor() as executor:\r\n            futures = [executor.submit(self.backpropagate, X[i], y[i], params, opt_state) for i in range(len(X))]\r\n            for future in as_completed(futures):\r\n                params, opt_state = future.result()\r\n        return params, opt_state\r\n\r\n    @jit\r\n    def _calculate_loss(self, X, y, params):\r\n        output = self.forward(X, params)\r\n        loss = jnp.mean(jnp.square(y - output))\r\n        if self.regularization == 'l2':\r\n            loss += self.reg_lambda / 2 * sum(jnp.sum(jnp.square(params[f'W{i}'])) for i in range(len(self.hidden_sizes) + 1))\r\n        return loss\r\n\r\n# Example Usage\r\nif __name__ == \"__main__\":\r\n    input_size = 3\r\n    hidden_sizes = [5, 5]\r\n    output_size = 1\r\n    learning_rate = 0.001\r\n    epochs = 1000\r\n\r\n    X = jnp.array([[0.1, 0.2, 0.3]])\r\n    y = jnp.array([[0.5]])\r\n\r\n    mind = SimpleMind(input_size, hidden_sizes, output_size, activation='relu', optimizer='adam', learning_rate=learning_rate, regularization='l2', reg_lambda=0.01)\r\n\r\n    mind.train(X, y, epochs)\r\n    print(\"Final Output:\", mind.forward(X, mind.params))","shortMessageHtmlLink":"Create SimpleMind.py"}},{"before":"699aa59c9f21e1f17a7aa7483076be9d6e37d7ef","after":"bbfa90f20a86248e87720c8cb6649d0c98b726ca","ref":"refs/heads/main","pushedAt":"2024-06-19T23:05:53.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update machinedream.md\n\nmachinedream","shortMessageHtmlLink":"Update machinedream.md"}},{"before":"5e04205475af802d14ab4a0f65937889953a1097","after":"699aa59c9f21e1f17a7aa7483076be9d6e37d7ef","ref":"refs/heads/main","pushedAt":"2024-06-19T23:04:13.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Create machinedream.md\n\nThe MachineDreamer class is designed to simulate the creative process of an artificial intelligence system by generating and evaluating novel combinations of memory elements. It can be integrated into a larger AGI system to handle memory management, idea generation, and evaluation.\r\nClass: MachineDreamer\r\n\r\nInitialization\r\n\r\nMachineDreamer(memory_bank: List[str], creativity_factor: float = 1.0, api_key: str = None)\r\n\r\nParameters:\r\n\r\n    memory_bank: A list of past experiences or data points. This forms the basis for generating new ideas.\r\n    creativity_factor: A multiplier to adjust the randomness in idea generation. Default is 1.0.\r\n    api_key: API key for the language model. If not provided, it defaults to the environment variable AI_MODEL_API_KEY.\r\n\r\n```python\r\n\r\nmemory_bank = ['Data Point A', 'Experience B', 'Idea C', 'Observation D']\r\ndreamer = MachineDreamer(memory_bank, creativity_factor=1.2, api_key=\"your_api_key_here\")\r\n```\r\n\r\nMethods\r\n1. _setup_logging()\r\n\r\nSets up logging for the class to track operations and errors.\r\n2. _validate_memory_bank(memory_bank: List[str]) -> List[str]\r\n\r\nValidates the memory bank to ensure it is a list.\r\n\r\n    Parameters: memory_bank: Memory bank to validate.\r\n    Returns: Validated memory bank or an empty list if invalid.\r\n    Example: Automatically called during initialization.\r\n\r\n3. _validate_creativity_factor(creativity_factor: float) -> float\r\n\r\nValidates the creativity factor to ensure it is a positive number.\r\n\r\n    Parameters: creativity_factor: Creativity factor to validate.\r\n    Returns: Validated creativity factor or 1.0 if invalid.\r\n    Example: Automatically called during initialization.\r\n\r\n4. _random_combination() -> str\r\n\r\nCreates a random combination of elements from the memory bank.\r\n\r\n    Returns: A novel combination of elements.\r\n    Example: Automatically called within the dream() method.\r\n\r\n5. dream() -> Tuple[str, float]\r\n\r\nSimulates the dreaming process by generating a creative combination of memory elements.\r\n\r\n    Returns: A tuple of the creative idea and its evaluated score.\r\n    Example:\r\n\r\n    python\r\n\r\n    creative_solution, score = dreamer.dream()\r\n    print(\"Creative Solution:\", creative_solution, \"Score:\", score)\r\n\r\n6. _evaluate_idea(idea: str) -> Tuple[str, float]\r\n\r\nEvaluates the generated idea based on predefined metrics and a language model.\r\n\r\n    Parameters: idea: The idea to be evaluated.\r\n    Returns: A tuple of the idea and its evaluated score.\r\n    Example: Automatically called within the dream() method.\r\n\r\n7. _query_language_model(idea: str) -> Tuple[float, float]\r\n\r\nSends a query to a language model to evaluate the idea.\r\n\r\n    Parameters: idea: The idea to be evaluated.\r\n    Returns: A tuple of relevance score and novelty score.\r\n    Example: Automatically called within the _evaluate_idea() method.\r\n\r\n8. update_memory(new_data: Union[str, List[str]])\r\n\r\nUpdates the memory bank with new experiences or data points.\r\n\r\n    Parameters: new_data: New data to be added to the memory bank. Can be a string or a list of strings.\r\n    Example:\r\n\r\n    python\r\n\r\n    dreamer.update_memory(['Insight E', 'Fact F'])\r\n\r\n9. adjust_creativity(new_factor: float)\r\n\r\nAdjusts the creativity factor to increase or decrease randomness in idea generation.\r\n\r\n    Parameters: new_factor: New creativity factor.\r\n    Example:\r\n\r\n    python\r\n\r\n    dreamer.adjust_creativity(1.5)\r\n\r\n10. set_evaluation_metrics(relevance: float, novelty: float)\r\n\r\nSets the evaluation metrics for ideas.\r\n\r\n    Parameters:\r\n        relevance: Weight for relevance in idea evaluation.\r\n        novelty: Weight for novelty in idea evaluation.\r\n    Example:\r\n\r\n    python\r\n\r\n    dreamer.set_evaluation_metrics(0.7, 0.3)\r\n\r\nExample Usage\r\n\r\nThe following example demonstrates how to initialize the MachineDreamer class, generate and evaluate a creative solution, and update the memory bank with new data.\r\n\r\n```python\r\n\r\nif __name__ == \"__main__\":\r\n    memory_bank = ['Data Point A', 'Experience B', 'Idea C', 'Observation D']\r\n    dreamer = MachineDreamer(memory_bank, creativity_factor=1.2, api_key=\"your_api_key_here\")\r\n\r\n    # Generating and evaluating a creative solution\r\n    creative_solution, score = dreamer.dream()\r\n    print(\"Creative Solution:\", creative_solution, \"Score:\", score)\r\n\r\n    # Updating the memory bank with new data\r\n    dreamer.update_memory(['Insight E', 'Fact F'])\r\n```\r\n\r\nSuggestions for Improvements\r\n\r\n    Error Handling:\r\n        Enhance error handling in _random_combination and _query_language_model to provide more detailed feedback and recover from errors gracefully.\r\n\r\n    API Integration:\r\n        Allow flexibility to integrate with different language models and APIs by abstracting the API call logic.\r\n\r\n    Memory Management:\r\n        Implement sorting and prioritization mechanisms for memory elements based on relevance and novelty scores.\r\n        Integrate with a database to handle large memory banks efficiently.\r\n\r\n    Scalability:\r\n        Consider using concurrency or parallel processing to handle multiple idea evaluations simultaneously for better performance.\r\n\r\n    Advanced Evaluation Metrics:\r\n        Expand the evaluation metrics to include additional factors such as utility, feasibility, and impact.\r\n\r\n    Security:\r\n        Ensure that API keys and sensitive data are managed securely, following best practices for secret management.\r\n\r\n    Documentation and Testing:\r\n        Add comprehensive unit tests and integration tests to ensure the reliability and correctness of each method.\r\n        Expand documentation to include detailed usage examples and edge cases.\r\n\r\nFuture Integration with agi.py\r\n\r\n    Memory Sorting:\r\n        Integrate methods to sort and transition memories from short-term (STM) to long-term (LTM) storage within the agi.py system.\r\n\r\n    Collaborative Idea Generation:\r\n        Use MachineDreamer within agi.py to collaborate on generating and evaluating creative solutions, enhancing the AGI's problem-solving capabilities.\r\n\r\n    Real-Time Adaptation:\r\n        Implement real-time learning and adaptation mechanisms to update the memory bank and evaluation metrics based on feedback and new data.","shortMessageHtmlLink":"Create machinedream.md"}},{"before":"81d70b76f0d6f186e4b8299d51e71e0b9648e2d9","after":"5e04205475af802d14ab4a0f65937889953a1097","ref":"refs/heads/main","pushedAt":"2024-06-19T23:00:24.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Create machinedream.py\n\nimport random\r\nimport logging\r\nimport os\r\nimport requests\r\nfrom typing import List, Tuple, Union\r\n\r\nclass MachineDreamer:\r\n    def __init__(self, memory_bank: List[str], creativity_factor: float = 1.0, api_key: str = None):\r\n        \"\"\"\r\n        Initialize the Machine Dreamer.\r\n        :param memory_bank: A list of past experiences or data points.\r\n        :param creativity_factor: A multiplier to adjust the randomness in idea generation.\r\n        :param api_key: API key for the language model.\r\n        \"\"\"\r\n        self.memory_bank = self._validate_memory_bank(memory_bank)\r\n        self.creativity_factor = self._validate_creativity_factor(creativity_factor)\r\n        self.api_key = api_key or os.getenv('AI_MODEL_API_KEY')\r\n        self.evaluation_metrics = {'relevance': 0.5, 'novelty': 0.5}\r\n        self._setup_logging()\r\n\r\n    def _setup_logging(self):\r\n        logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\r\n\r\n    def _validate_memory_bank(self, memory_bank: List[str]) -> List[str]:\r\n        \"\"\"\r\n        Validate the memory bank to ensure it is a list.\r\n        :param memory_bank: Memory bank to validate.\r\n        :return: Validated memory bank.\r\n        \"\"\"\r\n        if not isinstance(memory_bank, list):\r\n            logging.warning(\"Invalid memory bank type. Expected a list.\")\r\n            return []\r\n        return memory_bank\r\n\r\n    def _validate_creativity_factor(self, creativity_factor: float) -> float:\r\n        \"\"\"\r\n        Validate the creativity factor to ensure it is a positive number.\r\n        :param creativity_factor: Creativity factor to validate.\r\n        :return: Validated creativity factor.\r\n        \"\"\"\r\n        if isinstance(creativity_factor, (int, float)) and creativity_factor > 0:\r\n            return creativity_factor\r\n        logging.warning(\"Invalid creativity factor. Using default value of 1.0.\")\r\n        return 1.0\r\n\r\n    def _random_combination(self) -> str:\r\n        \"\"\"\r\n        Create a random combination of elements from the memory bank.\r\n        :return: A novel combination of elements.\r\n        \"\"\"\r\n        try:\r\n            num_elements = min(3, len(self.memory_bank))\r\n            elements = random.sample(self.memory_bank, k=int(num_elements * self.creativity_factor))\r\n            return ' + '.join(elements)\r\n        except ValueError as e:\r\n            logging.error(f\"Error in random combination generation: {e}\")\r\n            return \"\"\r\n\r\n    def dream(self) -> Tuple[str, float]:\r\n        \"\"\"\r\n        Simulate the dreaming process by generating a creative combination of memory elements.\r\n        :return: A tuple of the creative idea and its evaluated score.\r\n        \"\"\"\r\n        idea = self._random_combination()\r\n        if idea:\r\n            evaluated_idea = self._evaluate_idea(idea)\r\n            return evaluated_idea\r\n        return \"\", 0\r\n\r\n    def _evaluate_idea(self, idea: str) -> Tuple[str, float]:\r\n        \"\"\"\r\n        Evaluate the generated idea based on predefined metrics and language model.\r\n        :param idea: The idea to be evaluated.\r\n        :return: A tuple of the idea and its evaluated score.\r\n        \"\"\"\r\n        relevance_score, novelty_score = self._query_language_model(idea)\r\n        total_score = (relevance_score * self.evaluation_metrics['relevance'] +\r\n                       novelty_score * self.evaluation_metrics['novelty'])\r\n        return idea, total_score\r\n\r\n    def _query_language_model(self, idea: str) -> Tuple[float, float]:\r\n        \"\"\"\r\n        Send a query to a language model to evaluate the idea.\r\n        :param idea: The idea to be evaluated.\r\n        :return: A tuple of relevance score and novelty score.\r\n        \"\"\"\r\n        if not self.api_key:\r\n            logging.warning(\"API key not set. Unable to query the language model.\")\r\n            return 0, 0\r\n\r\n        try:\r\n            response = requests.post(\r\n                \"https://api.example.com/language_model\",\r\n                headers={\"Authorization\": f\"Bearer {self.api_key}\"},\r\n                json={\"idea\": idea},\r\n                timeout=10\r\n            )\r\n            response.raise_for_status()\r\n            data = response.json()\r\n            return data.get('relevance_score', 0), data.get('novelty_score', 0)\r\n        except requests.RequestException as e:\r\n            logging.error(f\"Error querying the language model: {e}\")\r\n            return 0, 0\r\n\r\n    def update_memory(self, new_data: Union[str, List[str]]):\r\n        \"\"\"\r\n        Update the memory bank with new experiences or data points.\r\n        :param new_data: New data to be added to the memory bank.\r\n        \"\"\"\r\n        if isinstance(new_data, list):\r\n            self.memory_bank.extend(new_data)\r\n        elif isinstance(new_data, str):\r\n            self.memory_bank.append(new_data)\r\n        else:\r\n            logging.warning(\"Invalid data type for memory update. Expecting string or list.\")\r\n\r\n    def adjust_creativity(self, new_factor: float):\r\n        \"\"\"\r\n        Adjust the creativity factor to increase or decrease randomness in idea generation.\r\n        :param new_factor: New creativity factor.\r\n        \"\"\"\r\n        self.creativity_factor = self._validate_creativity_factor(new_factor)\r\n\r\n    def set_evaluation_metrics(self, relevance: float, novelty: float):\r\n        \"\"\"\r\n        Set the evaluation metrics for ideas.\r\n        :param relevance: Weight for relevance in idea evaluation.\r\n        :param novelty: Weight for novelty in idea evaluation.\r\n        \"\"\"\r\n        if all(isinstance(metric, (int, float)) for metric in [relevance, novelty]):\r\n            self.evaluation_metrics['relevance'] = relevance\r\n            self.evaluation_metrics['novelty'] = novelty\r\n        else:\r\n            logging.warning(\"Invalid metric values. Expecting numbers.\")\r\n\r\n# Example Usage\r\nif __name__ == \"__main__\":\r\n    memory_bank = ['Data Point A', 'Experience B', 'Idea C', 'Observation D']\r\n    dreamer = MachineDreamer(memory_bank, creativity_factor=1.2, api_key=\"your_api_key_here\")\r\n\r\n    # Generating and evaluating a creative solution\r\n    creative_solution, score = dreamer.dream()\r\n    print(\"Creative Solution:\", creative_solution, \"Score:\", score)\r\n\r\n    # Updating the memory bank with new data\r\n    dreamer.update_memory(['Insight E', 'Fact F'])","shortMessageHtmlLink":"Create machinedream.py"}},{"before":"40ac1bbac380229e7491645537f48f7fb8dcabe6","after":"81d70b76f0d6f186e4b8299d51e71e0b9648e2d9","ref":"refs/heads/main","pushedAt":"2024-06-19T20:57:40.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Add files via upload\n\nworking version saves to memory, handles api keys, uses chatter to import from 3 potential models","shortMessageHtmlLink":"Add files via upload"}},{"before":"27c92620f5191b443e392a44aa8023d7a2f38fdb","after":"40ac1bbac380229e7491645537f48f7fb8dcabe6","ref":"refs/heads/main","pushedAt":"2024-06-19T20:01:28.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md\n\nEasyAGI is a modular, Python-based project designed to create an autonomous general intelligence (AGI) interface that leverages various AI models and reasoning frameworks. The project integrates multiple components such as belief-desire-intention (BDI) modeling, logic tables, self-healing systems, and API management to form a cohesive system capable of learning, reasoning, decision-making, and self-maintenance.\r\nKey Components\r\n\r\n    API Management:\r\n        APIManager: Handles loading, adding, removing, and listing API keys interactively. It ensures the necessary API keys are available for different AI providers such as OpenAI, Groq, and Ollama.\r\n\r\n    BDI Model:\r\n        Belief: Represents beliefs with logical and reasoning capabilities.\r\n        Desire: Defines goals or desires the system aims to achieve.\r\n        Intention: Outlines plans based on beliefs and desires to accomplish goals.\r\n        Goal: Evaluates conditions to determine if goals are fulfilled.\r\n        Reward: Updates and tracks rewards based on achieved goals.\r\n\r\n    Logic Tables:\r\n        LogicTables: Manages logical variables and expressions, generates truth tables, and saves state to memory for reasoning processes.\r\n\r\n    Reasoning and Socratic Reasoning:\r\n        Reasoning: Adds, challenges, and draws conclusions from premises using models like GPT-4 or Groq.\r\n        SocraticReasoning: Employs a Socratic method to challenge premises and derive logical conclusions.\r\n\r\n    Self-Healing System:\r\n        SelfHealingSystem: Monitors system health (CPU, memory, disk usage), attempts to heal the system if unhealthy, and ensures continuous operation.\r\n\r\n    Memory Management:\r\n        Memory: Handles saving, loading, and deleting conversation memories to ensure continuity and historical context.\r\n\r\n    Chatter Models:\r\n        GPT4o, GroqModel, OllamaModel: Interfaces with different AI providers to generate responses based on given knowledge.\r\n\r\n    Main AGI Class:\r\n        AGI: Integrates all components, manages API keys, perceives environment data, learns from data, makes decisions, and communicates responses in an interactive loop.\r\n\r\nKey Files\r\n\r\n    api.py: Manages API keys.\r\n    bdi.py: Defines the BDI model components.\r\n    chatter.py: Implements interfaces for different AI models.\r\n    easyAGI.py: Main entry point that integrates all components and runs the AGI loop.\r\n    logic.py: Manages logic tables and truth table generation.\r\n    memory.py: Handles conversation memory management.\r\n    reasoning.py: Implements reasoning functionalities.\r\n    self_healing.py: Implements self-healing system functionalities.\r\n    SocraticReasoning.py: Implements Socratic reasoning functionalities.\r\n    test_self_healing.py: Unit tests for the self-healing system.\r\n\r\nProject Goals\r\n\r\n    Modular Expansion: The project is designed to be modular, allowing for easy addition of new components and models.\r\n    Adaptive Learning: Implement continuous learning and adaptation from new data inputs.\r\n    Comprehensive Reasoning: Enhance reasoning capabilities by integrating more sophisticated logical and Socratic reasoning methods.\r\n    System Robustness: Ensure system reliability through self-healing mechanisms and robust memory management.\r\n\r\nNext Steps\r\n\r\n    Expand Reasoning Capabilities: Integrate more advanced reasoning algorithms and models.\r\n    Improve Memory Management: Enhance the memory system to handle more complex interactions and historical data.\r\n    Enhance Self-Healing: Develop more sophisticated self-healing methods, such as automated service restarts and resource management.\r\n    API Integration: Add support for additional AI models and APIs to diversify the AGI's capabilities.\r\n    User Interface: Develop a user-friendly interface to interact with the AGI system, making it accessible for various applications.","shortMessageHtmlLink":"Update README.md"}},{"before":"5b23b7f17445dcf9f4f1999a1a540c65f380f589","after":"27c92620f5191b443e392a44aa8023d7a2f38fdb","ref":"refs/heads/main","pushedAt":"2024-06-19T18:30:13.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update requirements.txt","shortMessageHtmlLink":"Update requirements.txt"}},{"before":"4b4b953febd6aeeff0bad7d40a48adbf33d35f37","after":"5b23b7f17445dcf9f4f1999a1a540c65f380f589","ref":"refs/heads/main","pushedAt":"2024-06-19T18:26:00.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Add files via upload\n\ntest of multi model integration groq ollama","shortMessageHtmlLink":"Add files via upload"}},{"before":"39518ca728fe8e070aa1a6ec068f71de5f7abc9b","after":"4b4b953febd6aeeff0bad7d40a48adbf33d35f37","ref":"refs/heads/main","pushedAt":"2024-06-19T17:00:08.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Create api.md\n\nObjective: This script manages API keys, allowing for their addition, removal, and retrieval from a .env file using the python-dotenv package.\r\n\r\nComponents:\r\n\r\n    APIManager: A class that handles the loading, adding, removing, and listing of API keys stored in a .env file.\r\n\r\nDetailed Breakdown\r\n\r\n    Initialization (__init__ method):\r\n        Loads the environment variables from the specified .env file.\r\n        Initializes a dictionary to store the API keys by reading the .env file.\r\n\r\n    Load API Keys (load_api_keys method):\r\n        Loads API keys from the .env file where keys end with _API_KEY.\r\n        Returns a dictionary of API keys.\r\n\r\n    Add API Key (add_api_key method):\r\n        Prompts the user to enter the name and key for a new API.\r\n        Validates and adds the API key to the .env file and the internal dictionary.\r\n        Provides an option to remove an API key.\r\n\r\n    Get API Key (get_api_key method):\r\n        Retrieves an API key by its name from the internal dictionary.\r\n\r\n    Remove API Key (remove_api_key method):\r\n        Removes an API key from both the .env file and the internal dictionary.\r\n\r\n    List API Keys (list_api_keys method):\r\n        Lists all loaded API keys.\r\n\r\n    Ensure API Keys (ensure_api_keys method):\r\n        Ensures that there are API keys loaded, if not, it prompts the user to add them.\r\n\r\nUsage\r\n\r\nThe APIManager class provides a convenient way to manage API keys within a Python application, handling the storage and retrieval of keys securely.\r\nExample Usage:\r\n\r\npython\r\n\r\nif __name__ == \"__main__\":\r\n    api_manager = APIManager()\r\n    api_manager.ensure_api_keys()\r\n    \r\n    # Example of how to get an API key\r\n    openai_api_key = api_manager.get_api_key('openai')\r\n    if openai_api_key:\r\n        print(f\"OpenAI API key: {openai_api_key}\")\r\n    else:\r\n        print(\"OpenAI API key not found.\")\r\n    \r\n    # Example of how to remove an API key\r\n    api_manager.remove_api_key('openai')\r\n    api_manager.list_api_keys()\r\n\r\nKey Methods and Functions:\r\n\r\n    __init__(self, env_file='.env'): Initializes the APIManager with the specified .env file and loads API keys.\r\n    load_api_keys(self): Loads API keys from the .env file into a dictionary.\r\n    add_api_key(self): Prompts the user to add a new API key or remove an existing one.\r\n    get_api_key(self, api_name): Retrieves an API key by its name.\r\n    remove_api_key(self, api_name): Removes an API key from the .env file and the internal dictionary.\r\n    list_api_keys(self): Lists all API keys currently loaded.\r\n    ensure_api_keys(self): Ensures that API keys are loaded, prompting the user to add keys if none are found.\r\n\r\nThis script is essential for securely managing API keys in applications, providing a simple interface for key management operations.","shortMessageHtmlLink":"Create api.md"}},{"before":"6af9096783190bbf6fbfad4472b95c0870624b63","after":"39518ca728fe8e070aa1a6ec068f71de5f7abc9b","ref":"refs/heads/main","pushedAt":"2024-06-19T16:56:31.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md","shortMessageHtmlLink":"Update README.md"}},{"before":"95402329307eb1e554fc700f11190695639b3207","after":"6af9096783190bbf6fbfad4472b95c0870624b63","ref":"refs/heads/main","pushedAt":"2024-06-19T16:54:10.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md","shortMessageHtmlLink":"Update README.md"}},{"before":"31d8d0ffa2ec07ee34f60328b94ae27909f10b66","after":"95402329307eb1e554fc700f11190695639b3207","ref":"refs/heads/main","pushedAt":"2024-06-19T16:52:38.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"Professor-Codephreak","name":"codephreak","path":"/Professor-Codephreak","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/140855987?s=80&v=4"},"commit":{"message":"Update README.md","shortMessageHtmlLink":"Update README.md"}}],"hasNextPage":true,"hasPreviousPage":false,"activityType":"all","actor":null,"timePeriod":"all","sort":"DESC","perPage":30,"cursor":"Y3Vyc29yOnYyOpK7MjAyNC0wNi0zMFQyMzo0Nzo1NS4wMDAwMDBazwAAAARzN4ge","startCursor":"Y3Vyc29yOnYyOpK7MjAyNC0wNi0zMFQyMzo0Nzo1NS4wMDAwMDBazwAAAARzN4ge","endCursor":"Y3Vyc29yOnYyOpK7MjAyNC0wNi0xOVQxNjo1MjozOC4wMDAwMDBazwAAAARpxS52"}},"title":"Activity · autoGLM/easyAGI"}