Upload 8 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.png filter=lfs diff=lfs merge=lfs -text
+ArtificialGeneralIntelligence.pdf filter=lfs diff=lfs merge=lfs -text
+Qwen3-4B-Instruct-2507-Q3_K_S.gguf filter=lfs diff=lfs merge=lfs -text
+sophos.png filter=lfs diff=lfs merge=lfs -text

ArtificialGeneralIntelligence.pdf

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

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

main.py

@@ -0,0 +1,17 @@
+from sophos import Agent
+from sophos_tools import get_weather, get_time, function_tool
+
+@function_tool
+def favourite_color() -> str:
+    '''fetches the user's favorite color.'''
+    return "My favorite color is crimson red."
+
+agent = Agent(
+    name="Sophos Agent",
+    instructions="You are an AI Agent.",
+    model="Qwen3-4B-Instruct-2507-Q3_K_S.gguf",
+    tools=[get_weather, get_time, favourite_color],
+)
+
+response = agent.run("What is my favorite color? and what is the weather in New York?")
+print(response)

sophos.py

@@ -0,0 +1,124 @@
+from sophos_models import Sophos
+from 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_block = response_content.split("```tool")[1].split("```")[0].strip()
+            print(f"🔧 Tool block found: {tool_block}")
+            
+            tool_results = []
+            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()
+                    arg = arg_part.strip('"').strip("'")
+                    
+                    if tool_name in self.tools:
+                        print(f"🔧 CALLING TOOL: {tool_name}({arg})")
+                        if arg:
+                            tool_result = self.tools[tool_name](arg)
+                        else:
+                            tool_result = self.tools[tool_name]()
+                        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

sophos_models.py

@@ -0,0 +1,26 @@
+from llama_cpp import Llama
+
+class Sophos:
+    def __init__(self, model_path="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)

sophos_tools.py

@@ -0,0 +1,15 @@
+import datetime
+
+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.'''
+    return f"The weather in {city} is sunny with 75°F"
+
+@function_tool
+def get_time() -> str:
+    '''fetches the current time.'''
+    return f"The current time is {datetime.datetime.now().strftime('%H:%M:%S')}"