first_commit

.gitignore

@@ -0,0 +1,7 @@
+models/*
+generated_images/*
+knowledge_base/*
+__pycache__/*
+myenv/*
+.vscode/*
+.fake

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Salvatore Rossitto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

RBotReloaded.py

@@ -0,0 +1,492 @@
+import os
+import re
+from datetime import datetime, timedelta
+from threading import Thread  
+import asyncio
+import requests
+import streamlit as st
+import json
+import time
+from bs4 import BeautifulSoup
+from PIL import Image
+import base64
+import io
+import google_free_search
+from langchain.vectorstores import FAISS # For storing embeddings
+from langchain.chains import RetrievalQA, ConversationalRetrievalChain # Chains for QA
+from langchain.utilities import TextRequestsWrapper, WikipediaAPIWrapper # Tools
+from langchain.document_loaders import DirectoryLoader, PyMuPDFLoader, TextLoader, WebBaseLoader # Loaders
+from langchain.document_loaders.recursive_url_loader import RecursiveUrlLoader # Load URLs
+from langchain.schema import AIMessage, HumanMessage, get_buffer_string # Chat history
+from langchain.text_splitter import RecursiveCharacterTextSplitter # Split text  
+from langchain.llms import TextGen, LlamaCpp, CTransformers # Language models
+from langchain.memory import ConversationBufferMemory # Chat memory
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler # Logging
+from langchain.agents import Tool, load_tools # Tools
+from langchain.input import get_colored_text # Console colors
+from langchain.embeddings import (
+    HuggingFaceEmbeddings, 
+    LlamaCppEmbeddings,
+    SentenceTransformerEmbeddings,
+)
+from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline # Image generation
+from typing import Any, Dict, List  
+import torch
+from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_from_original_stable_diffusion_ckpt
+
+# Config  
+EMBD_CHUNK_SIZE = 512  
+AI_NAME = "Agent Llama"
+USER_NAME = "Buddy"
+
+# Helper to load LM  
+def create_llm(model_id="./models/mistral-7b-instruct-v0.1.Q4_K_M.gguf", load_4bit=False, load_8bit=False, ctx_len = 8192, temperature=0.5, top_p=0.95):
+  if (model_id.startswith("http")):
+    print(f"Creating TextGen LLM base_url:{model_id}")
+    return TextGen(model_url=model_id, callbacks=[StreamingStdOutCallbackHandler()])
+  if (os.path.exists(model_id)):
+    try:       
+      print(f"Creating LlamaCpp LLM model_id:{model_id}")
+      return LlamaCpp(model_path=model_id, verbose=True, n_batch=521, alpha_value=1,rope_freq_base=10000,compress_pos_emb=ctx_len / 4096, n_ctx=ctx_len, load_in_4bit=load_4bit, load_in_8bit=load_8bit, temperature=temperature,top_p=top_p)                
+    except Exception as ex:
+      try:       
+        print(f"Creating CTransformers LLM model_id:{model_id}")
+        config = {
+          "context_length": ctx_len,
+          "batch_size":521,
+          "seed":79,
+          "top_p":top_p,
+          "temperature":temperature
+        }
+        return CTransformers(model=model_id, model_type='llama', config=config)        
+
+      except Exception as ex:
+        print(f"Load Error {str(ex)}")
+        return None
+
+# Class to store pages and run queries
+class StorageRetrievalLLM:
+
+  def __init__(self, stored_pages_folder : str, llm, embeddings):
+    
+    # Initialize storage
+    os.makedirs(stored_pages_folder, exist_ok=True)
+    self.stored_pages_folder = stored_pages_folder
+    self.llm = llm
+    self.embeddings = embeddings
+    
+    # Try loading existing, else create new
+    try:
+      print(f"Loading StorageRetrievalLLM from disk")
+      self.vectorstore = FAISS.load_local(folder_path=stored_pages_folder, embeddings=embeddings)
+      self.chain = self.create_chain()
+    except:
+      print(f"Initializing a new instance of StorageRetrievalLLM")
+            
+      print(f"Loading PDF")
+      self.vectorstore = None
+      self.chain = None
+      
+      # Load pages 
+      loader = DirectoryLoader(stored_pages_folder, glob="**/*.pdf", loader_cls=PyMuPDFLoader)
+      documents = loader.load()
+      
+      # Split into chunks
+      text_splitter = RecursiveCharacterTextSplitter(chunk_size=EMBD_CHUNK_SIZE, chunk_overlap=100)
+      documents = text_splitter.split_documents(documents)
+
+      if len(documents) > 0:
+        # Create index
+        print(f"Creating FAISS index FROM {len(documents)} documents")            
+        self.vectorstore = FAISS.from_documents(documents, embeddings)    
+        self.vectorstore.save_local(folder_path=stored_pages_folder)    
+      else:
+        print(f"Initializing with empty FAISS index")
+        self.vectorstore = FAISS.from_texts(["Knowledge Base: Use the learning tools (learnOnline, wikipedia, etc...) to increase tour knownledge."], embeddings)      
+            
+      if llm:
+        # Create chain
+        self.chain = self.create_chain()
+                      
+  # Helper to create retrieval chain            
+  def create_chain(self, vectorstore = None, llm = None, embeddings = None):
+    if vectorstore is None:
+      vectorstore = self.vectorstore
+    if llm is None:
+      llm = self.llm            
+    if embeddings is None:
+      embeddings = self.embeddings            
+
+    print(f"Creating Retriever llm chain")
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    chain = ConversationalRetrievalChain.from_llm(llm=llm, retriever=retriever, return_source_documents=False)
+    return chain
+
+  # Add URL
+  def addUrlToMemory(self, url : str, summarize = True):
+    
+    loader = RecursiveUrlLoader(url=url, max_depth=2, extractor=lambda x: BeautifulSoup(x, "html.parser").text)
+    docs = loader.load()
+    
+    # Split 
+    splitter = RecursiveCharacterTextSplitter()
+    documents = splitter.split_documents(docs)
+    
+    # Add
+    self.vectorstore.add_documents(documents)
+    
+    # Update chain
+    self.chain = self.create_chain()
+    
+    # Summarize
+    if summarize:
+      return self.query(query=f"return a short summary about the website {url}, try to not exceed 3500 tokens")
+    else:
+      return f"URL {url} Parsed and collected into memory vectorstore..."
+        
+  # Add document
+  def addDocumentToMemory(self, doc : str, summarize = True):
+    
+    # Load file
+    file_path = doc if os.path.exists(doc) else os.path.join("data", doc)  
+    loader = DirectoryLoader(file_path, glob="**/*.pdf", loader_cls=PyMuPDFLoader)       
+    documents = loader.load()
+    
+    # Split and add
+    splitter = RecursiveCharacterTextSplitter()
+    documents = splitter.split_documents(documents)  
+    self.vectorstore.add_documents(documents)
+    
+    # Update chain
+    self.chain = self.create_chain()
+    
+    # Summarize
+    if summarize:
+      return self.query(query=f"return a short summary about the doc {file_path}, try to not exceed 3500 tokens")
+    else:
+      return f"File {file_path} Parsed and collected into memory vectorstore..."
+                        
+  # Add text file
+  def addTextFileToMemory(self, file_path : str, summarize = True):
+    
+    # Load file
+    loader = TextLoader(path=file_path, loader_cls=PyMuPDFLoader)
+    documents = loader.load()
+    
+    # Split and add
+    splitter = RecursiveCharacterTextSplitter()            
+    documents = splitter.split_documents(documents)
+    self.vectorstore.add_documents(documents)
+    
+    # Update chain
+    self.chain = self.create_chain()
+
+    # Summarize
+    if summarize:
+      return self.query(query=f"return a short summary about the file {file_path}, try to not exceed 3500 tokens")
+    else:
+      return f"File {file_path} Parsed and collected into memory vectorstore..."
+      
+  # Add text            
+  def addTextToMemory(self, text : str, summarize = True):
+    
+    # Add text
+    self.vectorstore.add_texts([text])
+    
+    # Update chain
+    self.chain = self.create_chain()                             
+
+    # Summarize
+    if summarize:
+      return self.query(query=f"return a short summary about the text {text[:10]}, try to not exceed 3500 tokens")
+    else:
+      return "Text Parsed and collected into memory vectorstore..."      
+
+  # Run query
+  def query(self, query: str, chat_history = []):
+    res = self.chain({"question" : query, "chat_history" : chat_history})           
+    return res['answer']
+
+# Class for agent  
+class RBotAgent:        
+
+  def __init__(self, llm, tools, max_iterations=3, observations_callback=None):
+    self.llm = llm
+    self.tools = tools
+    self.max_iterations=max_iterations
+    self.observations_callback = observations_callback
+
+  # Get tools prompt
+  def tools_prompt(self):
+    return "\n".join([ f"Action: {tool.name}(query_params) - Description: {tool.description}" for tool in self.tools])
+
+  # Main handler  
+  def __call__(self, params):
+    
+    input = params["input"]
+    chat_history = params["chat_history"]
+    formatted_history = get_buffer_string(chat_history, human_prefix="USER")
+    
+    prompt = f"""
+EXAMPLE 1:
+USER: Find me a recipe for chocolate chip cookies. 
+AI: SearchAndReply("chocolate chip cookies recipe", 5) #params query, max_results=5
+
+EXAMPLE 2:
+USER: Show me pictures of cute puppies.
+AI: ImageGenerator("cute puppies", 512, 512) #params: prompt, width=512, height=512, denoise_strength=0.75, guidance_scale=7.5, negative_prompt = "")
+EXAMPLE 3:
+USER: Explain the concept of blockchain.
+AI: KnowledgeBaseQuery("Explain blockchain") #params query
+
+EXAMPLE 4:  
+USER: Find me recent news about cryptocurrency.
+AI: SearchAndReply("recent cryptocurrency news")  #params query, max_results=5
+
+EXAMPLE 5:
+USER: Can you calculate the factorial of 5?
+AI: Calculator("factorial(5)") #params query
+
+###REAL CONVERSATION:\n
+SYS:Today is {str(datetime.now().date())},  
+You are {AI_NAME} a smart and helpful AI assistant with access to external tools and knowledge.
+Please reply to the user with a truth and useful response, if you do not know the answer or you are not sure or you need more recent informations, delegate the task replying with ActionName(action_input) with the most appropriate of the available actions (you call them like functions).\nCurrent Conversation History:
+
+###AVAILABLE TOOL ACTIONS  
+{self.tools_prompt()}  
+
+{formatted_history}
+USER: {input}
+AI:
+"""
+    observations = []
+
+    # Try calling tools
+    tool_names = [tool.name.lower() for tool in self.tools]
+    for i in range(self.max_iterations):
+      
+      print(f"iteration {i+1} - sending prompt:\n" + prompt)
+      for i in [1,2,3]:
+        output = str(self.llm(prompt,stop=["USER:","AI:","SYS:","[INST]","[/INST]"])).strip()
+        if output: break
+      
+      
+      return_role = output.split(":")[0]
+      return_message = output[len(return_role)+1:].split("[INST]")[0].split("[/INST]")[0].split("User")[0].split("USER")[0].strip()
+      
+      # Try to parse action request
+      action_name = None
+      action_input = None
+      matches = re.findall(r"(\w+)\((.+?)\)", return_message)
+      for match in matches:
+        if len(match) > 1 and match[0] and match[1]:
+          if match[0].strip().lower() in tool_names:
+            action_name = match[0].strip().lower()
+            action_input = match[1].strip().replace("query_params", "").strip().replace("()","")
+            break
+
+      # Try unformatted            
+      if not action_name or not action_input:   
+        lines = output.split("\n")
+
+        
+        for line in lines:
+          for tool in tool_names:
+            if f"{tool}:" in line.lower() or f"{tool}(" in line.lower():
+              action_name = tool
+              action_input = line[line.lower().find(tool)+len(tool):].strip().replace("query_params", "").strip().replace("()","")
+              print(f"Matched unformatted action request. {action_name}:{action_input} from line: {line}")
+              break
+      
+      # Call tool if found
+      if action_name and action_input:                
+        for tool in self.tools:
+          if tool.name.lower() in action_name:
+            print(f"Calling action:{tool.name} with input:{action_input}")
+            observations.append(f"Calling action:{tool.name} with input:{action_input}")
+
+            params_list  = action_input.split(",")
+            try:
+              try:
+                res = tool.func(*params_list)
+              except:
+                res = tool.func(action_input)
+            except Exception as ex:
+              res = f"{action_name} execution error: {str(ex)}"
+            
+            print(f"Action Output: {res}")
+            observations.append(f"Action Output: {res}")
+            prompt = prompt + f"Action: {tool.name}({action_input})\nSYS:{res}\nAI:"            
+      else:
+        final_response = "\n*Reasoning: ".join(observations) + f"\n{output}" if len(observations) > 0 else f"\n{output}"
+        print(f"Final Anser: {final_response}")
+        return { "output": final_response }
+
+    return { "output": "Max Iterations reached. Last Output:\n" + output}
+
+# Main agent class
+class SmartAgent:   
+
+  def __init__(self, model_id: str, conversation_model = "", emb_model="all-MiniLM-L6-v2", load_in_4bit=False, load_in_8bit=True, ctx_len=16384, temp=0.1, top_p=0.95, max_iterations=3, observations_callback = None):
+  
+    self.chat_history = []
+    self.max_iterations = max_iterations
+    self.model = model_id        
+    self.current_message = ""
+
+    # Load LM
+    self.llm = create_llm(model_id, load_4bit=load_in_4bit, load_8bit=load_in_8bit, ctx_len=ctx_len, temperature=temp, top_p=top_p)        
+
+    # Load embeddings
+    self.embeddings = SentenceTransformerEmbeddings(model_name=emb_model)
+    
+    # Initialize memory
+    self.memory_chain = StorageRetrievalLLM(stored_pages_folder="./knowledge_base", llm=self.llm, embeddings=self.embeddings)
+    
+    #TOOL REQUEST
+    self.requests_tool = TextRequestsWrapper()
+    
+    #Wikipedia
+    self.wikipedia_tool = WikipediaAPIWrapper()
+
+    self.image2image_gen_pipe = None
+    self.text2image_gen_pipe = None
+
+    # Create agent
+    self.smartAgent = self.create_smart_agent()
+
+    print("Smart Agent Initialized")
+
+  def reset_context(self):
+      self.chat_history.clear()
+      
+    # Create image 
+  def createImage(self, prompt, width=512, height=512, denoise_strength=0.75, guidance_scale=7.5, model_id = 'dreamshaper_8.safetensors'):
+    try:
+        init_image = None
+        if (os.path.exists("./image_gen_guide.jpg")):
+            init_image = Image.open("./image_gen_guide.jpg")               
+
+        images = []         
+        if init_image is None:
+            if self.text2image_gen_pipe is None:
+                if torch.cuda.is_available():
+                    print(f"Loading Stable model {model_id} into GPU")
+                    self.text2image_gen_pipe = StableDiffusionPipeline.from_single_file("./models/" + model_id, torch_dtype=torch.float16, verbose=True, use_safetensors=True)
+                    self.text2image_gen_pipe = self.text2image_gen_pipe.to("cuda")   
+                else:
+                    print(f"Loading Stable model {model_id} into CPU")
+                    self.text2image_gen_pipe = StableDiffusionPipeline.from_single_file("./models/" + model_id, torch_dtype=torch.float32, verbose=True, use_safetensors=True)
+                    self.text2image_gen_pipe = self.text2image_gen_pipe.to("cpu")                   
+            print("generating image from promt...")
+            images = self.text2image_gen_pipe(prompt, width=width, height=height).images
+        else:
+            if self.image2image_gen_pipe is None:
+                if torch.cuda.is_available():
+                    print(f"Loading Stable model {model_id} into GPU")
+                    self.image2image_gen_pipe = StableDiffusionImg2ImgPipeline.from_single_file("./models/" + model_id, torch_dtype=torch.float16, verbose=True, use_safetensors=True)
+                    self.image2image_gen_pipe = self.image2image_gen_pipe.to("cuda")   
+                else:
+                    print(f"Loading Stable model {model_id} into CPU")
+                    self.image2image_gen_pipe = StableDiffusionImg2ImgPipeline.from_single_file("./models/" + model_id, torch_dtype=torch.float32, verbose=True, use_safetensors=True)
+                    self.image2image_gen_pipe = self.image2image_gen_pipe.to("cpu")                   
+            print("generating image from promt+image...")
+            init_image = init_image.convert("RGB")
+            images = self.image2image_gen_pipe(prompt, image=init_image, width=width, height=height, strength=denoise_strength, guidance_scale=guidance_scale).images
+        
+        paths = []
+        for image in (images if images is not None else []):
+            # Create a filename based on the current date and time
+            filename = f'image_{datetime.now().strftime("%Y%m%d%H%M%S")}{(len(paths)+1)}.jpg'
+            # Save the image to the specified path
+            file_path = f"./generated_images/{filename}"
+            image.save(file_path)
+            paths.append(file_path)
+        return f"Generated images from prompt \"{prompt}\" saved to files: {', '.join(paths)}"        
+    except Exception as e:
+        print(f"error in createImageLocal: {e}")            
+        return "Unable to generate file"
+    
+  def load_and_split_documents(self, url, max_depth=2):
+      loader = RecursiveUrlLoader(url, max_depth=max_depth, extractor=lambda x: BeautifulSoup(x, "html.parser").text)
+      docs = loader.load()
+      splitter = RecursiveCharacterTextSplitter()
+      return splitter.split_documents(docs)
+      
+  def search_and_reply(self, query, max_results=5):
+      vectorstore = None        
+      sources = ""
+      res_cnt = 0
+      results = google_free_search.gsearch(query=query)
+      #urls = [ur['link'].strip() for ur in results]
+      urls = []
+      for result in results:
+          link = result['link']
+          title = result['title']
+          if (link.startswith("http://") or link.startswith("https://")):
+              res_cnt = res_cnt +1
+              if res_cnt > max_results: break
+              print(f"- Found Valid Link {title} : {link}")
+              sources += f"{title}, "
+              urls.append(link)
+          else:
+              print(f"ERROR! Invalid link: {link} for result: {title}")
+
+      if len(urls) > 0:
+          import concurrent.futures            
+          print(f"Loading {len(urls)} urls into a vectore store")
+          
+          with concurrent.futures.ThreadPoolExecutor() as executor:
+              future_results = [executor.submit(self.load_and_split_documents, url) for url in urls]
+          
+          documents = []
+          for future in concurrent.futures.as_completed(future_results):
+              documents.extend(future.result())
+              
+          if len(documents) > 0:
+              vectorstore = FAISS.from_documents(documents, self.embeddings) 
+
+      if vectorstore is not None:
+          retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+          chain = RetrievalQA.from_chain_type(llm=self.llm, chain_type="stuff", retriever=retriever)   
+          response = chain.run(self.current_message + " " + datetime.now().strftime("%Y/%m/%d"))
+          ret_message = response #['answer']
+          return ret_message
+      else:
+          return f"Unable to acquire results from web search results:{len(results)} - valids:{res_cnt}"            
+          
+  # Main handler
+  def agent_generate_response(self, user_message):
+  
+    start_time = time.time()
+
+    self.current_message = user_message
+    # Get response
+    message_response = self.smartAgent({"input" : user_message, "chat_history" : self.chat_history})             
+
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+            
+    # Format response
+    response = message_response['output'] + f" ({round(elapsed_time,2)}s)"
+    self.chat_history.append(HumanMessage(content=user_message))
+    self.chat_history.append(AIMessage(content=message_response['output']))
+    
+    return response
+
+  # Create agent
+  def create_smart_agent(self):
+  
+    # Tools
+    tools = [
+        Tool(name="SearchAndReply", func=self.search_and_reply, description="Search web and reply"),
+        Tool(name="Wikipedia", func=self.wikipedia_tool.run, description="Query Wikipedia"),   
+        Tool(name="ImageGenerator", func=self.createImage, description="Generate images"),
+        Tool(name="KnowledgeBaseQuery", func=self.memory_chain.query, description="Query knowledge base"),
+    ]    
+    tools.extend(load_tools(["llm-math"], llm=self.llm))  
+
+    # test_reply = self.llm(f"Hello {AI_NAME}")
+    # print(f"Test reply to Hello: {test_reply}")
+
+    return RBotAgent(llm=self.llm, tools=tools, max_iterations=self.max_iterations)

README.md

@@ -1,13 +1,57 @@
----
-title: AgentLlama007B
-emoji: 👁
-colorFrom: pink
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.27.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Agent Llama007B: A Conversational AI Assistant
+
+![AgentLlama007B Logo](avatar.png)
+
+## Overview
+
+AgentLlama007B is a powerful Conversational AI Assistant designed for natural language interactions and task automation. It leverages state-of-the-art language models and offers seamless integration with external tools and knowledge sources. Whether you need to engage in casual conversations or perform specific tasks, AgentLlama007B has you covered.
+
+## Key Features
+
+- **Natural Language Conversations**: Engage in human-like conversations powered by local language models.
+- **Tool Integration**: Execute various tools, including image generation, web search, Wikipedia queries, and more, all within the conversation.
+- **Persistent Memory**: Contextual knowledge is stored in a vector database, providing continuity and enhancing the conversational experience.
+- **Modular Architecture**: Easily extend AgentLlama007B with additional skills and tools to suit your specific needs.
+
+## Getting Started
+
+To start using AgentLlama007B, follow these simple steps:
+
+Clone the repo and create a folder "models", than download the Models you need from hugging face and put them in the models folder.
+I use mistral-7b-instruct-v0.1.Q4_K_M.gguf for chat/instructions and dreamshaper_8 for images generation (:P you'll need dreamshaper_8.json and dreamshaper_8.safetensors)
+
+1. Install the required dependencies by running `pip install -r requirements.txt`.
+
+2. Run the main Streamlit app:
+
+```bash
+streamlit run agent_llama_ui.py
+```
+
+3. Alternatively, you can integrate the agent into your Python code:
+
+```python
+from agent_llama import SmartAgent
+
+agent = SmartAgent()
+
+while True:
+    user_input = input("You: ")
+    response = agent.agent_generate_response(user_input)
+    print("Bot:", response)
+```
+
+For more details on customization, model configuration, and tool parameters, refer to the code documentation.
+
+## Implementation
+
+AgentLlama007B's core logic is encapsulated in the `RBotAgent` class, which manages the conversational flow and tool integration. The knowledge base tool, `StorageRetrievalLLM`, uses persistent memory with a FAISS index of document embeddings. Various tools are provided, each encapsulating specific skills such as image generation and web search. The modular architecture allows easy replacement of components like the language model.
+
+## Credits
+
+This project was created by Salvatore Rossitto as a passion project and a learning endeavor. Contributions from the community are welcome and encouraged.
+
+## License
+
+AgentLlama007B is an open-source project released under the MIT license. You are free to use, modify, and distribute it as per the terms of the license.
+

agent_llama_ui.py

@@ -0,0 +1,249 @@
+import streamlit as st
+from streamlit_chat import message
+import os
+import io
+from dotenv import load_dotenv
+import requests
+import glob
+import json
+import shutil
+from RBotReloaded import SmartAgent
+import time
+from PIL import Image
+from langchain.schema import AIMessage, HumanMessage
+
+load_dotenv()
+
+
+default_model = ""
+default_context = 8192
+default_load_type = "Auto"
+default_iterations = 2
+default_temperature = 0.5
+default_topp = 0.95
+
+@st.cache_resource
+def agent(model, temperature, top_p, context_length, load_8bit, load_4bit, max_iterations):    
+    ag = SmartAgent(f"./models/{model}" if os.path.exists(f"./models/{model}") else model, temp=temperature, top_p=top_p, load_in_4bit=load_4bit, load_in_8bit=load_8bit, ctx_len=context_length, max_iterations=max_iterations) if model else None
+    st.session_state["temperature_executive"] = temperature
+    st.session_state["max_iterations_executive"] = max_iterations
+    st.session_state["model_executive"] = model
+    st.session_state["context_length_executive"] = context_length
+    st.session_state["load_options_executive"] = "Load 4-bit" if load_8bit else "Load 4-bit" if load_4bit else "Auto"
+    st.session_state["top_p_executive"] = top_p
+
+    return ag
+    
+def get_models():
+    supported_extensions = ["bin","pth","gguf"]
+    models_directory = "./models"  # Replace with the actual path
+    # Use os.listdir to get a list of filenames in the directory
+    models = os.listdir(models_directory)
+    # Filter out any subdirectories, if any
+    models = [model for model in models if (model.lower().split(".")[-1] in supported_extensions) and os.path.isfile(os.path.join(models_directory, model))]  
+    if len(models) == 0:
+        from huggingface_hub import hf_hub_download
+        hf_hub_download(repo_id="TheBloke/Mistral-7B-Instruct-v0.1-GGUF", filename="mistral-7b-instruct-v0.1.Q4_K_M.gguf", local_dir=models_directory)
+        hf_hub_download(repo_id="digiplay/DreamShaper_8", filename="dreamshaper_8.safetensors", local_dir=models_directory)        
+        
+    models.append("http://localhost:5000")    
+    return models
+
+def current_agent():
+    model = st.session_state.get("model", default_model)
+    temperature = st.session_state.get("temperature", default_temperature)
+    max_iterations = st.session_state.get("max_iterations", default_iterations)
+    context_length = st.session_state.get("context_length", default_context)
+    load_options = st.session_state.get("load_options", default_load_type)    
+    top_p = st.session_state.get("top_p", default_topp)
+    
+    model = st.session_state.get("model_executive", model)
+    temperature = st.session_state.get("temperature_executive", temperature)
+    max_iterations = st.session_state.get("max_iterations_executive", max_iterations)
+    context_length = st.session_state.get("context_length_executive", context_length)
+    load_options = st.session_state.get("load_options_executive", load_options)    
+    top_p = st.session_state.get("top_p_executive", top_p)
+    
+    return agent(model, temperature, top_p, context_length, load_options=="Load 8-bit", load_options=="Load 4-bit", max_iterations)
+
+def history():
+    return [] if current_agent() is None else current_agent().chat_history
+
+#@st.cache_data
+def generate_text(input):
+    start_time = time.time()
+    output = "Error: Model not Loaded!" if current_agent() is None else current_agent().agent_generate_response(input)
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+
+    print(f"\n----------------------")
+    print(f"Agent Reply: {output} - Input: {input}")
+    print(f"Elapsed Time: {elapsed_time} seconds")
+    print(f"Agent Reply: {output}")
+    print(f"\n----------------------")
+    return output + f" ({round(elapsed_time,2)}s)"
+
+
+def get_generated_files():
+    # Specify the directory path where the generated images are stored
+    directory = "./generated_images"
+
+    # Get the list of files in the directory
+    files = glob.glob(f"{directory}/*.jpg")  # Modify the file extension as per your generated image format
+
+    # Return the list of file paths
+    return files
+
+# Function to list files in the "./knowledge_base/" folder
+def list_files_in_knowledge_base_folder():
+    knowledge_base_folder = "./knowledge_base/"
+    files = os.listdir(knowledge_base_folder)
+    return [file for file in files if os.path.isfile(os.path.join(knowledge_base_folder, file))]
+
+# Function to add a file to the "./knowledge_base/" folder
+def add_file_to_knowledge_base(file):
+    knowledge_base_folder = "./knowledge_base/"
+    final_path = os.path.join(knowledge_base_folder, file.name)
+    
+    with open(final_path, "wb") as f:
+        f.write(file.read())
+
+    if current_agent() is None:
+        st.error("Model Not Loaded!")
+    else:
+        current_agent().memory_chain.addDocumentToMemory(os.path.join(knowledge_base_folder, file.name))
+
+# Function to add a file to the "./knowledge_base/" folder
+def set_image_gen_guide(file): 
+    bytes_data = io.BytesIO(file.read())
+    image = Image.open(bytes_data)
+    image = image.convert("RGB")
+    image.save("./image_gen_guide.jpg")
+    
+def unset_image_gen_guide():    
+    if os.path.exists("./image_gen_guide.jpg"):
+        os.remove("./image_gen_guide.jpg")
+        
+def get_index_size():        
+    index_file_path = "./knowledge_base/index.faiss"  # Replace with the actual path to your index file
+    if os.path.exists(index_file_path):
+        index_size = os.path.getsize(index_file_path)
+        return index_size / 1024
+    else:
+        print(f"{index_file_path} does not exist or is not accessible.")
+        return 0
+        
+# @cl.langchain_factory(use_async=True)
+# def factory():
+#     return current_agent().smartAgent
+
+def render_simple_chat():
+    models = get_models()
+    models.append("")
+
+    model = st.session_state.get("model", default_model)
+    temperature = st.session_state.get("temperature", default_temperature)
+    max_iterations = st.session_state.get("max_iterations", default_iterations)
+    context_length = st.session_state.get("context_length", default_context)
+    load_options = st.session_state.get("load_options", default_load_type)    
+    top_p = st.session_state.get("top_p", default_topp)
+
+    with st.sidebar:
+        st.image("./avatar.png")
+        st.sidebar.title("LLM Options")
+        max_iterations = st.sidebar.slider("Max Iterations", min_value=1, max_value=10, step=1, key="max_iterations")
+        model = st.selectbox(label="Model", options=models, key="model")
+        if (not model.startswith("http")):
+            temperature = st.sidebar.slider("Temperature", min_value=0.1, max_value=1.0, step=0.1, key="temperature")
+            top_p = st.sidebar.slider("top_p", min_value=0.1, max_value=1.0, step=0.1, key="top_p")
+            context_length = st.sidebar.slider("Context Length", min_value=1024, max_value=131072, step=1024,  key="context_length")
+            # Load Options
+            load_options = st.sidebar.radio("Load Options", ["Auto", "Load 4-bit", "Load 8-bit"], key="load_options")
+
+        if (st.sidebar.button("Apply Changes to Model")):
+            st.session_state["temperature_executive"] = temperature
+            st.session_state["max_iterations_executive"] = max_iterations
+            st.session_state["model_executive"] = model
+            st.session_state["context_length_executive"] = context_length
+            st.session_state["load_options_executive"] = load_options
+            st.session_state["top_p_executive"] = top_p
+            #st.experimental_rerun()
+
+        if st.sidebar.button("Reset Chat Context", disabled=not (current_agent() is not None and len(current_agent().chat_history) > 0)) and current_agent() is not None:
+            current_agent().reset_context()
+
+    st.sidebar.write("-----")
+
+    st.sidebar.title("Documents Context")
+    st.sidebar.subheader(f"Current Memory Size {round(get_index_size() / 1024,2)}MB")
+
+    uploaded_file = st.sidebar.file_uploader("Drag and Drop a File to ./knowledge_base/", type=["txt", "pdf", "docx"])     
+    
+    if st.sidebar.button("Reset Long Term Memory", disabled=not (current_agent() is not None and get_index_size() > 0)) and current_agent() is not None:
+        current_agent().reset_knowledge()
+
+    st.sidebar.write("-----")
+
+    st.sidebar.title("Images Generation")
+
+    if os.path.exists("./image_gen_guide.jpg"):
+        st.sidebar.image("./image_gen_guide.jpg")
+        if st.sidebar.button("Remove Image Generation Guidance"):
+            unset_image_gen_guide()
+            st.experimental_rerun()
+    else:
+        image_gen_guide = st.sidebar.file_uploader("Drag and Drop an image for the image generation", type=["jpg", "png"])  
+        if image_gen_guide:
+            set_image_gen_guide(image_gen_guide)
+            st.sidebar.success(f"File '{image_gen_guide.name}' set as image generation guidance.")
+    
+    if uploaded_file:
+        add_file_to_knowledge_base(uploaded_file)
+        st.sidebar.success(f"File '{uploaded_file.name}' added to Knowledge Base.")
+        
+    with st.sidebar:
+        #GENERATED FILES
+        generated_files = get_generated_files()
+        st.sidebar.subheader("Generated Files")
+        for file_path in generated_files:      
+            st.write("---")
+            st.write(file_path.split("/")[-1].split("\\")[-1])      
+            st.image(file_path)
+
+    i = 0
+    for m in history():
+        i = i +1
+        gen = str(m.content)
+        #saved to files: ./generated_images/image_202310091819331.jpg
+        if str(gen).endswith(".jpg") and os.path.exists(gen.split(" ")[-1]):
+            st.image(gen.split(" ")[-1])
+
+        message(gen, is_user=m.type.lower() == "human", key=str(i))
+        
+    user_input = st.chat_input("Prompt", key="input_text")
+    if user_input:
+        message(user_input, is_user=True, key=str(i+1))
+        res = generate_text(user_input)
+        message(res, is_user=False, key=str(i+2))         
+            
+
+##### BEGIN MAIN #####
+if 'generated' not in st.session_state:
+    st.session_state['generated'] = []
+
+if 'past' not in st.session_state:
+    st.session_state['past'] = []
+            
+if 'model' not in st.session_state:
+    st.session_state['model'] = default_model
+    st.session_state['temperature'] = default_temperature
+    st.session_state['max_iterations'] = default_iterations
+    st.session_state['context_length'] = default_context
+    st.session_state['load_options'] = default_load_type
+    st.session_state['top_p'] =  default_topp
+    
+st.set_page_config(page_title="Agent Llama", page_icon="🤖", layout="wide")
+
+st.title("Agent Llama")
+
+render_simple_chat()

google_free_search.py

@@ -0,0 +1,74 @@
+from bs4 import BeautifulSoup
+import requests, json, lxml
+
+def gsearch(query : str, max: int = 10, country = "us", lang = "en"):
+    # https://docs.python-requests.org/en/master/user/quickstart/#passing-parameters-in-urls
+        params = {
+            "q": query.replace("\"",""), # query example
+            "hl": lang,          # language
+            "gl": country,          # country of the search, UK -> United Kingdom
+            "start": 0,          # number page by default up to 0
+            "num": max          # parameter defines the maximum number of results to return.
+        }
+
+        # https://docs.python-requests.org/en/master/user/quickstart/#custom-headers
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36"
+        }
+
+        page_limit = 10
+        page_num = 0
+        data = []
+
+        while True:
+            page_num += 1
+            html = requests.get("https://www.google.com/search", params=params, headers=headers, timeout=30)
+            soup = BeautifulSoup(html.text, 'lxml')
+            
+            for result in soup.select('.tF2Cxc'):
+                title = result.select_one('.DKV0Md').text
+                link = result.select_one('.yuRUbf a')['href']
+
+                # sometimes there's no description and we need to handle this exception
+                try: 
+                    snippet = result.select_one('#rso .lyLwlc').text
+                except: 
+                    snippet = None
+
+                if (link.startswith("http")):
+                    data.append({
+                    'title': title,
+                    'link': link,
+                    'snippet': snippet
+                    })
+                
+            if page_num == page_limit:
+                break
+            if soup.select_one(".d6cvqb a[id=pnnext]"):
+                params["start"] += 10
+            else:
+                break
+        
+        return data
+    
+
+# -------------
+# '''
+# [
+#   {
+#     "title": "Tesla: Electric Cars, Solar & Clean Energy",
+#     "link": "https://www.tesla.com/",
+#     "snippet": "Tesla is accelerating the world's transition to sustainable energy with electric cars, solar and integrated renewable energy solutions for homes and ..."
+#   },
+#   {
+#     "title": "Tesla, Inc. - Wikipedia",
+#     "link": "https://en.wikipedia.org/wiki/Tesla,_Inc.",
+#     "snippet": "Tesla, Inc. is an American electric vehicle and clean energy company based in Palo Alto, California, United States. Tesla designs and manufactures electric ..."
+#   },
+#   {
+#     "title": "Nikola Tesla - Wikipedia",
+#     "link": "https://en.wikipedia.org/wiki/Nikola_Tesla",
+#     "snippet": "Nikola Tesla was a Serbian-American inventor, electrical engineer, mechanical engineer, and futurist best known for his contributions to the design of the ..."
+#   }
+# ]
+# '''

requirements.txt

@@ -0,0 +1,46 @@
+accelerate
+aiohttp
+anyio
+bitsandbytes
+bs4
+diffusers
+transformers
+faiss-cpu
+fastapi
+git-python
+google-search-results
+httptools
+huggingface
+huggingface-hub
+json5
+langchain
+numexpr
+llama_cpp_python
+psutil
+PyMuPDF
+safetensors
+selenium
+sentence-transformers
+sentencepiece
+streamlit_chat
+streamlit>=0.86.0
+textblob
+undetected-chromedriver
+urllib3
+virtualenv
+wikipedia
+datetime
+asyncio
+requests
+bs4
+Pillow
+langchain
+googletrans
+torch
+torchaudio
+#torchaudio==2.0.1+cu117
+torchvision
+python-dotenv
+lxml
+ctransformers
+omegaconf

start_agent.bat

@@ -0,0 +1,22 @@
+@echo off
+
+rem Define the name of your virtual environment
+set ENV_NAME=myenv
+
+rem Check if the virtual environment folder exists
+if not exist %ENV_NAME% (
+    rem Create a new virtual environment
+    python -m venv %ENV_NAME%
+)
+
+rem Activate the virtual environment
+call %ENV_NAME%\Scripts\activate
+
+rem Install the required packages from requirements.txt
+python -m pip install -r requirements.txt
+
+rem Run your Streamlit application
+python -m streamlit run agent_llama_ui.py
+
+rem Deactivate the virtual environment
+deactivate