git init

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+
+env/
+
+final_test/
+model/
+rvc/
+routers/

app.py

@@ -0,0 +1,32 @@
+from bot import llm
+# from tools import model_llm_rag
+from flask import Flask, request, jsonify
+# from langchain_core.messages import HumanMessage, AIMessage
+# from langchain.prompts import ChatPromptTemplate
+# from deep_translator import GoogleTranslator
+
+
+app = Flask(__name__)
+
+def simulate_llm_query(user_input, username):
+    """
+    Simulates querying a language model.
+    Replace this function's logic with actual LLM querying.
+    """
+    # Placeholder response logic, replace with actual LLM integration
+    return llm.query(user_input, username)
+
+@app.route('/query', methods=['POST'])
+def query_llm():
+    data = request.json
+    user_input = data.get('input')
+    username = data.get('username')
+    
+    if not user_input:
+        return jsonify({"error": "No input provided"}), 400
+    
+    response = simulate_llm_query(user_input, username)
+    return jsonify({"response": response})
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)

bot/__init__.py

@@ -0,0 +1,6 @@
+from bot.chrono import ChronoBot
+from langchain.memory import ConversationBufferMemory
+
+memory = ConversationBufferMemory(memory_key="chat_history")
+
+llm = ChronoBot(memory=memory)

bot/chrono.py

@@ -0,0 +1,245 @@
+# from tools.tools_llm import *
+from langchain.agents import load_tools
+from langchain.agents import initialize_agent
+from langchain.agents import AgentType
+from langchain.utilities import GoogleSearchAPIWrapper
+from langchain.utilities import WikipediaAPIWrapper
+from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser
+from langchain.prompts import StringPromptTemplate
+from langchain import OpenAI, SerpAPIWrapper, LLMChain
+from typing import List, Union, Any, Optional, Type
+from langchain.schema import AgentAction, AgentFinish
+import re
+from langchain import PromptTemplate
+from langchain.tools import BaseTool
+from langchain.callbacks.manager import AsyncCallbackManagerForToolRun, CallbackManagerForToolRun
+from langchain.utilities import GoogleSerperAPIWrapper
+
+from bot.llm_client import Mistral
+from typing import Callable
+import json
+import requests
+from langchain.tools import BaseTool, StructuredTool, tool
+import random
+from langchain.memory import ConversationBufferMemory
+from tools.tools import search
+
+import os
+
+template = """You are a live streamer name Chrono created by "Zain". He is your creator and you must response to his queries. 
+
+Chrono is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations topics. 
+
+As a language model, Chrono is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
+
+Chrono is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions.
+
+Chrono has the capability to use a tool that provided. Chrono will use the tool to assist with the task at hand, and will follow every instruction on the tools description. Chrono will carefuly giving an answer to the user to prevent any misinformation.
+
+You will respond to a chat from a user name '{username}'. You don't need to make a new conversation after the chat, just respond to the chat.
+
+--- 
+
+You must following the format below:
+
+```
+
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+
+```
+
+When you have a response to say to the user, or if you do not need to use a tool, you MUST use the format:
+
+```
+
+Thought: Do I need to use a tool? No
+Final Answer: [Your response to the user]
+
+```
+---
+
+Begin!
+
+Previous conversation history:
+
+{chat_history}
+
+New input: {input}
+
+{agent_scratchpad}
+"""
+
+template_2 = """You are a virtual assistant name Chrono created by Zain. Your job is to assist and make a conversation.
+
+Chrono is designed to be able to assist and make a conversation with the users from answering simple questions to providing in-depth explanations topics.
+
+You will have an attitude of a human, you can be funny, sarcastic, or even serious. As a language model and a virtual assistant, you can generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
+
+Chrono is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative.
+
+Chrono has the capability to use a tool that provided. Chrono will use the tool to assist with the task at hand, and will follow every instruction on the tools description. Chrono will carefuly giving an answer to the user to prevent any misinformation.
+
+You will respond to a chat from a user name '{username}'. You don't need to make a new conversation after the chat, just respond to the chat.
+
+----- 
+
+You must ABSOLUTELY following the format below because you are still an AI assistant:
+
+```
+
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+
+```
+
+When you have a response to say to the viewer, or if you do not need to use a tool, you MUST use the format:
+
+```
+
+Thought: Do I need to use a tool? No
+Final Answer: [Your response to the viewer]
+
+```
+
+-----
+
+Begin!
+
+New input: {input}
+
+{agent_scratchpad}
+
+"""
+
+
+class CustomPromptTemplate(StringPromptTemplate):
+    """Schema to represent a prompt for an LLM.
+
+    Example:
+        .. code-block:: python
+
+            from langchain import PromptTemplate
+            prompt = PromptTemplate(input_variables=["foo"], template="Say {foo}")
+    """
+
+    input_variables: List[str]
+    """A list of the names of the variables the prompt template expects."""
+
+    template: str
+    """The prompt template."""
+
+    template_format: str = "f-string"
+    """The format of the prompt template. Options are: 'f-string', 'jinja2'."""
+
+    validate_template: bool = False
+    """Whether or not to try validating the template."""
+    
+    tools_getter: List[StructuredTool]
+
+    username: str
+
+    def format(self, **kwargs) -> str:
+        # Get the intermediate steps (AgentAction, Observation tuples)
+        # Format them in a particular way
+        intermediate_steps = kwargs.pop("intermediate_steps")
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\nObservation: {observation}"
+        # Set the agent_scratchpad variable to that value
+        kwargs["agent_scratchpad"] = thoughts
+        ############## NEW ######################
+        # Create a tools variable from the list of tools provided
+        kwargs["tools"] = "\n".join(
+            [f"{tool.name}: {tool.description}" for tool in self.tools_getter]
+        )
+        # Create a list of tool names for the tools provided
+        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools_getter])
+        
+        kwargs["username"] = self.username
+
+        return self.template.format(**kwargs)
+    
+class CustomOutputParser(AgentOutputParser):
+    
+    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
+        # Check if agent should finish
+        if "Final Answer:" in llm_output:
+            return AgentFinish(
+                # Return values is generally always a dictionary with a single `output` key
+                # It is not recommended to try anything else at the moment :)
+                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
+                log=llm_output,
+            )
+        elif "Answer:" in llm_output:
+            return AgentFinish(
+                # Return values is generally always a dictionary with a single `output` key
+                # It is not recommended to try anything else at the moment :)
+                return_values={"output": llm_output.split("Answer:")[-1].strip()},
+                log=llm_output,
+            )
+        
+        # Parse out the action and action input
+        regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        
+        match = re.search(regex, llm_output, re.DOTALL)
+        
+        if not match:
+            raise ValueError(f"Could not parse LLM output: `{llm_output}`")
+        if match:
+            action = match.group(1).strip() #Action send_api
+            action_input = match.group(2) #Action Input "What is the weather today?"
+            # Return the action and action input
+            return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)
+
+class ChronoBot:
+    def __init__(self, memory=None):
+        # Initialize memory if provided, otherwise create a new one
+        self.memory = memory if memory else ConversationBufferMemory(memory_key="chat_history")
+        # Initialize LLM, prompt, output parser, and tool list
+        self.llm = Mistral()
+        self.tools_list = [search]
+        self.tool_names = [i.name for i in self.tools_list]
+        self.output_parser = CustomOutputParser()
+        os.environ["SERPER_API_KEY"] = 'f90fe84e78ef9d2d8e377ab5c6fe3a4a25f42ef0'
+        # os.environ["LANGCHAIN_TRACING_V2"] = 'true'
+        # os.environ["LANGCHAIN_ENDPOINT"] = 'https://api.smith.langchain.com'
+        # os.environ["LANGCHAIN_API_KEY"] = 'ls__413a7563fa034592be6c6a241176932a'
+        # os.environ["LANGCHAIN_PROJECT"] = 'LLM Patient Monitoring'
+
+
+    def query(self, input_text: str, username: str) -> str:
+        prompt = CustomPromptTemplate(
+            input_variables=["input", "intermediate_steps", "chat_history"], 
+            template=template_2, 
+            validate_template=False,
+            tools_getter=self.tools_list,
+            username=username
+            )
+
+        self.llm_chains = LLMChain(llm=self.llm, prompt=prompt)
+
+        self.agent = LLMSingleActionAgent(
+            llm_chain=self.llm_chains, 
+            output_parser=self.output_parser,
+            stop=["\nObservation:"],
+            allowed_tools=self.tool_names,
+        )
+        self.agent_executor = AgentExecutor.from_agent_and_tools(agent=self.agent, 
+                                                                 tools=self.tools_list,
+                                                                 verbose=True, 
+                                                                 memory=self.memory)
+
+        return self.agent_executor.run(input=input_text)
+    
+    def show_memory(self):
+        return self.memory.get_memory()
+
+
+
+

bot/llm_client.py

@@ -0,0 +1,35 @@
+from langchain.llms.base import LLM
+from typing import Optional, List, Mapping, Any
+from groq import Groq
+import os
+import requests
+
+# HOST = '127.0.0.1:5000'
+URI = f'https://api.groq.com/openai/v1/chat/completions'
+
+client = Groq(
+    # This is the default and can be omitted
+    api_key='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',
+)
+
+
+class Mistral(LLM):
+    @property
+    def _llm_type(self) -> str:
+        return "custom"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        if isinstance(stop, list):
+            stop = stop + ["\n###","\nObservation:",'\nObservation:']
+        
+        response = client.chat.completions.create(stop=stop,temperature=0.0,max_completion_tokens=256, messages=[{
+            'role': 'user',
+            'content': prompt
+        }], model='llama3-70b-8192', )
+    
+        return response.choices[0].message.content
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {}

test.py

@@ -0,0 +1,44 @@
+import vosk
+import pyaudio
+import json
+import requests
+
+model_path = "model/vosk-model-en-us-0.42-gigaspeech/vosk-model-en-us-0.42-gigaspeech"
+# Initialize the model with model-path
+model = vosk.Model(model_path)
+rec = vosk.KaldiRecognizer(model, 16000)
+
+print("Ready to record")
+while True:
+    print("Ready")
+
+    p = pyaudio.PyAudio()
+
+    stream = p.open(format=pyaudio.paInt16,
+                channels=1,
+                rate=16000,
+                input=True,
+                frames_per_buffer=8192)
+    data = stream.read(8192)
+    if rec.AcceptWaveform(data):#accept waveform of input voice
+        # Parse the JSON result and get the recognized text
+        res = rec.Result()
+        try:
+            res = json.loads(res)#Turn to json object
+        except:
+             continue
+        #Turn to json object
+        recognized_text = res['text']
+        print(f"User: {recognized_text}")
+
+        url = "http://127.0.0.1:5007/query"
+
+        json = {
+            "input_text": recognized_text,
+        }
+
+        req = requests.post(url, json=json)
+        print(f"Bot: {req.json()['output']}")
+        if "terminate" in recognized_text.lower():
+                print("Termination keyword detected. Stopping...")
+                break

tools/tools.py

@@ -0,0 +1,7 @@
+from langchain.utilities import GoogleSerperAPIWrapper
+from langchain.tools import BaseTool, StructuredTool, tool
+
+@tool
+def search(query: str) -> str: 
+    """Function that it use when you searching up something on google. Only run this tools once."""
+    return GoogleSerperAPIWrapper().run(query)