Upload 10 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+agi/assets/AGI.png filter=lfs diff=lfs merge=lfs -text
+agi/assets/ArtificialGeneralIntelligence.pdf filter=lfs diff=lfs merge=lfs -text
+agi/assets/sophos.png filter=lfs diff=lfs merge=lfs -text
+agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,52 @@
----
-license: mit
----
+---
+license: mit
+language:
+- en
+base_model:
+- Qwen/Qwen3-4B-Instruct-2507
+---
+
+# AGI-3
+## Artificial General Intelligence
+
+<img src="agi/assets/AGI.png">
+
+## Overview
+This repository contains an implementation of a modular-agentic architecture for Artificial General Intelligence (AGI). The architecture is designed to facilitate the development of autonomous agents capable of complex reasoning, learning, and interaction with their environment.
+
+# Example
+
+```python
+from agi.sophos import Agent
+from agi.sophos_tools import *
+
+toolbox = all_tools()
+
+agent = Agent(
+    name="Sophos Agent",
+    instructions="You are an AI Agent.",
+    model="Qwen3-4B-Instruct-2507-Q3_K_S.gguf",
+    tools=toolbox,
+)
+
+prompt = "Roll a dice, also whats the weather in Tokyo?"
+response = agent.run(prompt)
+print(response) 
+``` 
+### Output: 
+```python
+
+"""
+You rolled a 4 on a 6-sided die. The weather in Tokyo is sunny with a temperature of 12°C during fall.
+"""
+
+```
+## Research Paper
+
+[Read the research paper](agi/assets/ArtificialGeneralIntelligence.pdf)
+
+This paper delineates a comprehensive architectural framework for the progressive realization of Artificial General Intelligence (AGI), predicated upon a modular-agentic paradigm. We present a system design that integrates sophisticated tool-use capabilities, hierarchical memory management, dynamic code execution, and nascent world-modeling functionalities. The proposed architecture, exemplified through a lightweight `Qwen3-4B-Instruct-2507-Q3_K_S.gguf` model, demonstrates a robust foundation for emergent cognitive properties such as autonomy, recursive self-improvement, and goal-oriented behavior. Furthermore, we explore the theoretical underpinnings of consciousness as an emergent property within complex neural architectures and postulate pathways towards super-intelligence through advanced computational and embodied interaction modalities. The exposition maintains a rigorous academic tone, employing advanced terminology to articulate the intricate conceptual and technical facets of AGI development.
+
+## Implementation
+
+This is a more advanced implementation of the original AGI repository. It includes more tools, better memory management, and a more advanced agent structure.

agent_example.py

@@ -0,0 +1,15 @@
+from agi.sophos import Agent
+from agi.sophos_tools import *
+
+toolbox = all_tools()
+
+agent = Agent(
+    name="Sophos Agent",
+    instructions="You are an AI Agent.",
+    model="agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf",
+    tools=toolbox,
+)
+
+prompt = "show me example html code, save it in a file named example.html"
+response = agent.run(prompt)
+print(response) 

agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ce20058cc0ed6b6c9213bb383589327e458c12ffce0842fc96867042d669c75
+size 1886997600

agi/assets/ArtificialGeneralIntelligence.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fb9e7d571936ff4cf2f36929eceedbfbfc0c88b601d50406a7e527472568549
+size 785625

agi/sophos.py

@@ -0,0 +1,149 @@
+from agi.sophos_models import Sophos
+from agi.sophos_tools import *
+
+class Agent:
+    def __init__(self, name: str, instructions: str, model: str, tools: list):
+        self.name = name
+        self.instructions = instructions
+        self.model = model
+        self.tools = {tool.__name__: tool for tool in tools if hasattr(tool, "_is_tool")}
+        self.sophos = Sophos(model_path=model)
+
+    def process_tool_calls(self, response_content: str):
+        """Process tool calls from response content and return results"""
+        if "```tool" not in response_content:
+            return None
+            
+        print("🔧 TOOL DETECTED - Processing...")
+        try:
+            tool_results = []
+            
+            # Find all tool blocks in the response
+            parts = response_content.split("```tool")
+            for i in range(1, len(parts)):  # Skip first part (before first ```tool)
+                tool_block = parts[i].split("```")[0].strip()
+                print(f"🔧 Tool block {i} found: {tool_block}")
+                
+                tool_lines = [line.strip() for line in tool_block.split('\n') if line.strip()]
+                
+                for tool_line in tool_lines:
+                    if "(" in tool_line and ")" in tool_line:
+                        tool_name = tool_line.split("(")[0].strip()
+                        arg_part = tool_line.split("(", 1)[1].rsplit(")", 1)[0].strip()
+                        
+                        if tool_name in self.tools:
+                            print(f"🔧 CALLING TOOL: {tool_name}({arg_part})")
+                            
+                            # Parse arguments more intelligently
+                            if not arg_part:
+                                # No arguments
+                                tool_result = self.tools[tool_name]()
+                            else:
+                                # Try to parse multiple arguments
+                                try:
+                                    # Try to evaluate the arguments as a tuple if there are commas
+                                    if ',' in arg_part:
+                                        # Multiple arguments - evaluate as tuple and unpack
+                                        args = eval(f"({arg_part})")
+                                        if isinstance(args, tuple):
+                                            tool_result = self.tools[tool_name](*args)
+                                        else:
+                                            tool_result = self.tools[tool_name](args)
+                                    else:
+                                        # Single argument
+                                        parsed_arg = eval(arg_part)
+                                        tool_result = self.tools[tool_name](parsed_arg)
+                                except Exception as e:
+                                    print(f"Error parsing arguments: {e}")
+                                    # If eval fails completely, treat as single string argument
+                                    arg = arg_part.strip('"').strip("'")
+                                    tool_result = self.tools[tool_name](arg)
+                            
+                            print(f"🔧 TOOL RESULT: {tool_result}")
+                            tool_results.append(f"{tool_name}: {tool_result}")
+                        else:
+                            print(f"🔧 ERROR: Tool {tool_name} not found")
+                            tool_results.append(f"Error: Tool {tool_name} not found")
+            
+            return tool_results if tool_results else None
+                        
+        except Exception as e:
+            print(f"Error parsing tool: {e}")
+            return None
+        
+    def get_tools_names_and_descriptions(self):
+        return {name: func.__doc__ for name, func in self.tools.items()}
+
+    def run(self, prompt: str):
+        system_prompt = f"""You are {self.name}. {self.instructions}
+
+Available tools: {self.get_tools_names_and_descriptions()}
+
+CRITICAL: To use a tool, respond with exactly this format:
+```tool
+get_weather(Tokyo)
+```
+
+You can use multiple tools:
+```tool
+get_weather(Tokyo)
+get_time()
+```
+
+YOU MUST USE A BLOCK FOR TOOLS, or the system will not understand you are calling a tool.
+CRITICAL:
+```tool
+<tool_name>(<arg>)
+```
+REMEMBER ALL TOOLS MUST BE INSIDE THE SAME BLOCK
+
+IMPORTANT WORKFLOW:
+1. If you need live information, use the appropriate tool(s) first
+2. Once you have the information you need, provide your final response WITHOUT any tool calls
+3. Do NOT call the same tool repeatedly unless the user asks for updated information
+4. After calling a tool once and getting results, provide your answer to the user
+
+user prompt: {prompt}
+"""
+        print(f"--- System Prompt ---\n{system_prompt}\n---------------------")
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": prompt}
+        ]
+
+        max_iterations = 99
+        iteration = 0
+        last_tool_calls = []
+        
+        while iteration < max_iterations:
+            iteration += 1
+            print(f"\n--- Iteration {iteration} ---")
+
+            response = self.sophos.ask(str(messages))
+
+            current_response = response 
+            print(f"AI Response: {current_response}")
+            
+            tool_results = self.process_tool_calls(current_response)
+            
+            if tool_results is None:
+                print("🏁 No tool calls detected - Agent finished!")
+                return current_response
+        
+            all_results = "\n".join(tool_results)
+            
+            # Check if we're repeating the same tool calls
+            current_tool_calls = [result.split(":")[0] for result in tool_results]
+            if current_tool_calls == last_tool_calls and iteration > 1:
+                print("⚠️ Detected repeated tool calls - forcing final response")
+                messages.append({"role": "assistant", "content": current_response})
+                messages.append({"role": "user", "content": f"Tool results:\n{all_results}\n\nYou have already called these tools. Now provide your final answer to the user without calling any more tools."})
+            else:
+                messages.append({"role": "assistant", "content": current_response})
+                messages.append({"role": "user", "content": f"Tool results:\n{all_results}\n\nNow provide your final response to the user. Do NOT call any more tools unless absolutely necessary."})
+            
+            last_tool_calls = current_tool_calls
+        
+        print(f"⚠️ Reached maximum iterations ({max_iterations})")
+        return current_response

agi/sophos_models.py

@@ -0,0 +1,26 @@
+from llama_cpp import Llama
+
+class Sophos:
+    def __init__(self, model_path="agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf"):
+        self.model_path = model_path
+        self.model = Llama(model_path=model_path, n_ctx=2048, n_gpu_layers=35)
+
+    def ask(self, prompt):
+        """Ask Sophos a question and return the answer."""
+        messages = [
+            {"role": "user", "content": prompt}
+        ]
+
+        output = self.model.create_chat_completion(messages, max_tokens=1050, temperature=0.7)
+        return output["choices"][0]["message"]["content"]
+
+if __name__ == "__main__":
+    sophos = Sophos()
+    
+    while True:
+        prompt = input("\nEnter your prompt: ")
+        if prompt.lower() in ['exit', 'quit', 'q']:
+            break
+        
+        response = sophos.ask(prompt)
+        print(response)

agi/sophos_tools.py

@@ -0,0 +1,180 @@
+import datetime
+import random
+import string
+import math
+from typing import List, Dict
+import os
+
+def function_tool(func):
+    func._is_tool = True
+    return func
+
+@function_tool
+def get_weather(city: str) -> str:
+    '''fetches weather information for a given city.'''
+    now = datetime.datetime.now()
+    month = now.month
+    
+    # Determine season and base temperature
+    if month in [12, 1, 2]:  # Winter
+        season = "winter"
+        base_temp = 2
+    elif month in [3, 4, 5]:  # Spring
+        season = "spring"
+        base_temp = 15
+    elif month in [6, 7, 8]:  # Summer
+        season = "summer"
+        base_temp = 28
+    else:  # Fall (9, 10, 11)
+        season = "fall"
+        base_temp = 12
+    
+    # Add random variation of +/- 5 degrees
+    temp = base_temp + random.randint(-5, 5)
+    
+    return f"The weather in {city} is sunny with {temp}°C during {season}"
+
+@function_tool
+def get_time() -> str:
+    '''fetches the current time.'''
+    return f"The current time is {datetime.datetime.now().strftime('%H:%M:%S')}"
+
+@function_tool
+def get_date() -> str:
+    '''fetches the current date.'''
+    return f"Today's date is {datetime.datetime.now().strftime('%Y-%m-%d')}"    
+
+@function_tool
+def get_day() -> str:
+    '''fetches the current day of the week.'''
+    return f"Today is {datetime.datetime.now().strftime('%A')}"
+
+@function_tool
+def calculate(expression: str) -> str:
+    '''performs basic arithmetic calculations.'''
+    try:
+        # Safely evaluate the arithmetic expression
+        result = eval(expression, {"__builtins__": None}, {})
+        return f"The result of {expression} is {result}"
+    except Exception as e:
+        return f"Error in calculation: {str(e)}"
+    
+@function_tool
+def generate_password(length: int = 12) -> str:
+    '''Generates a random password of specified length.'''
+    if length < 8:
+        return "Error: Password length must be at least 8 characters"
+    
+    characters = string.ascii_letters + string.digits + string.punctuation
+    password = ''.join(random.choice(characters) for _ in range(length))
+    return f"Generated password: {password}"
+
+@function_tool
+def convert_temperature(value: float, from_unit: str, to_unit: str) -> str:
+    '''Converts temperature between Celsius, Fahrenheit, and Kelvin.'''
+    from_unit = from_unit.lower()
+    to_unit = to_unit.lower()
+    
+    if from_unit == to_unit:
+        return f"{value}°{from_unit.upper()} is the same as {value}°{to_unit.upper()}"
+    
+    try:
+        if from_unit == 'celsius':
+            if to_unit == 'fahrenheit':
+                result = (value * 9/5) + 32
+                return f"{value}°C is {result:.2f}°F"
+            elif to_unit == 'kelvin':
+                result = value + 273.15
+                return f"{value}°C is {result:.2f}K"
+        elif from_unit == 'fahrenheit':
+            if to_unit == 'celsius':
+                result = (value - 32) * 5/9
+                return f"{value}°F is {result:.2f}°C"
+            elif to_unit == 'kelvin':
+                result = (value - 32) * 5/9 + 273.15
+                return f"{value}°F is {result:.2f}K"
+        elif from_unit == 'kelvin':
+            if to_unit == 'celsius':
+                result = value - 273.15
+                return f"{value}K is {result:.2f}°C"
+            elif to_unit == 'fahrenheit':
+                result = (value - 273.15) * 9/5 + 32
+                return f"{value}K is {result:.2f}°F"
+        else:
+            return "Error: Invalid temperature units. Use 'celsius', 'fahrenheit', or 'kelvin'."
+    except Exception as e:
+        return f"Error in conversion: {str(e)}"
+
+@function_tool
+def roll_dice(sides: int, rolls: int = 1) -> str:
+    '''Rolls a dice with specified sides a given number of times.'''
+    if sides < 1 or rolls < 1:
+        return "Error: Sides and rolls must be positive integers"
+    
+    results = [random.randint(1, sides) for _ in range(rolls)]
+    total = sum(results)
+    return f"Rolling {rolls} d{sides}: {results}, Total: {total}"
+
+@function_tool
+def word_count(text: str) -> str:
+    '''Counts the number of words in the given text.'''
+    if not text.strip():
+        return "Error: Empty text provided"
+    
+    words = text.split()
+    return f"The text contains {len(words)} words"
+
+@function_tool
+def get_factorial(number: int) -> str:
+    '''Calculates the factorial of a given number.'''
+    if not isinstance(number, int):
+        return "Error: Input must be an integer"
+    if number < 0:
+        return "Error: Factorial is not defined for negative numbers"
+    try:
+        result = math.factorial(number)
+        return f"The factorial of {number} is {result}"
+    except Exception as e:
+        return f"Error in factorial calculation: {str(e)}"
+
+@function_tool
+def list_sort(numbers: List[float], ascending: bool = True) -> str:
+    '''Sorts a list of numbers in ascending or descending order.'''
+    try:
+        sorted_numbers = sorted(numbers, reverse=not ascending)
+        order = "ascending" if ascending else "descending"
+        return f"Sorted list in {order} order: {sorted_numbers}"
+    except Exception as e:
+        return f"Error in sorting: {str(e)}"
+
+@function_tool
+def generate_uuid() -> str:
+    '''Generates a random UUID.'''
+    return f"Generated UUID: {str(random.uuid4())}"
+
+def all_tools():
+    """Returns a list of all functions decorated with @function_tool."""
+    tools = []
+    # Get all items in the current module's global namespace
+    current_module = globals()
+    
+    for name, obj in current_module.items():
+        # Check if it's a function and has the _is_tool attribute
+        if callable(obj) and hasattr(obj, '_is_tool') and obj._is_tool:
+            tools.append(obj)
+    
+    return tools
+
+@function_tool
+def save_file(file_path: str, content: str) -> str:
+    '''Saves content to a specified file path. use as save_file("filename.extension", "content") .for new lines use \\n'''
+    agent_sandbox_folder = "agi/sandbox/agent_sandbox/"
+    # make sure the folder exists
+    os.makedirs(agent_sandbox_folder, exist_ok=True)
+
+    try:
+        with open(agent_sandbox_folder + file_path, 'w') as file:
+            file.write(content)
+        return f"Content successfully saved to {agent_sandbox_folder + file_path}"
+    except Exception as e:
+        return f"Error saving file: {str(e)}"

main.py

@@ -0,0 +1,15 @@
+from agi.sophos import Agent
+from agi.sophos_tools import *
+
+toolbox = all_tools()
+
+agent = Agent(
+    name="Sophos Agent",
+    instructions="You are an AI Agent.",
+    model="agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf",
+    tools=toolbox,
+)
+
+prompt = "Roll a dice, also whats the weather in Tokyo?"
+response = agent.run(prompt)
+print(response)