groq llm

.env

@@ -0,0 +1 @@
+OPENAI_API_KEYi_key= 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

.gitignore

@@ -0,0 +1,4 @@
+
+/.cache
+*.ipynb
+*.pyc

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "debug streamlit",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "./.venv/Lib/site-packages/streamlit",  // /home/xx/tmp/venv/bin/streamlit",
+            "args": [
+                "run",
+                "app.py"
+            ],
+            "justMyCode": false
+        }
+    ]
+}

LLMCONFIG/ANTROPIC_CLAUDE_CONFIG_LIST.json

@@ -0,0 +1,35 @@
+[
+    {
+        "model": "claude-3-5-sonnet-20240620",
+        "api_key": "your Anthropic API Key goes here",
+        "api_type": "anthropic"
+    },
+    {
+        "model": "claude-3-sonnet-20240229",
+        "api_key": "your Anthropic API Key goes here",
+        "api_type": "anthropic",
+        "temperature": 0.5,
+        "top_p": 0.2, 
+        "max_tokens": 10000
+    },
+    {
+        "model":"claude-3-opus-20240229",
+        "api_key":"your api key",
+        "api_type":"anthropic"
+    },
+    {
+        "model":"claude-2.0",
+        "api_key":"your api key",
+        "api_type":"anthropic"
+    },
+    {
+        "model":"claude-2.1",
+        "api_key":"your api key",
+        "api_type":"anthropic"
+    },
+    {
+        "model":"claude-3.0-haiku",
+        "api_key":"your api key",
+        "api_type":"anthropic"
+    }
+]

LLMCONFIG/BEDROCK_CONFIG_LIST.json

@@ -0,0 +1,31 @@
+[
+    {
+        "api_type": "bedrock",
+        "model": "amazon.titan-text-premier-v1:0",
+        "aws_region": "us-east-1",
+        "aws_access_key": "",
+        "aws_secret_key": "",
+        "aws_session_token": "",
+        "aws_profile_name": ""
+    },
+    {
+        "api_type": "bedrock",
+        "model": "anthropic.claude-3-sonnet-20240229-v1:0",
+        "aws_region": "us-east-1",
+        "aws_access_key": "",
+        "aws_secret_key": "",
+        "aws_session_token": "",
+        "aws_profile_name": "",
+        "temperature": 0.5,
+        "topP": 0.2,
+        "maxTokens": 250
+    },
+    {
+        "api_type": "bedrock",
+        "model": "mistral.mixtral-8x7b-instruct-v0:1",
+        "aws_region": "us-east-1",
+        "aws_access_key": "",
+        "aws_secret_key": "",
+        "price": 0.0007
+    }
+]

LLMCONFIG/GOOGLE_GEMINI_CONFIG_LIST.json

@@ -0,0 +1,37 @@
+[
+    {
+        "model": "gemini-pro",
+        "api_type": "google",
+        "project_id": "autogen-with-gemini",
+        "location": "us-west1"
+    },
+    {
+        "model": "gemini-1.5-pro-001",
+        "api_type": "google",
+        "project_id": "autogen-with-gemini",
+        "location": "us-west1"
+    },
+    {
+        "model": "gemini-1.5-pro",
+        "api_type": "google",
+        "project_id": "autogen-with-gemini",
+        "location": "us-west1",
+        "google_application_credentials": "autogen-with-gemini-service-account-key.json"
+    },
+    {
+        "model": "gemini-pro-vision",
+        "api_type": "google",
+        "project_id": "autogen-with-gemini",
+        "location": "us-west1"
+    },
+    {
+        "model": "gemini-1.5-flash",
+        "api_key": "<REPLACE WITH YOUR GEMINI API KEY>",
+        "api_type": "google"
+   },
+   {
+        "model": "gemini-1.5-pro",
+        "api_key": "<REPLACE WITH YOUR GEMINI API KEY>",
+        "api_type": "google"
+   }
+]

LLMCONFIG/GROQ_CONFIG_LIST.json

@@ -0,0 +1,29 @@
+[
+   
+    {
+        "model": "llama3-70b-8192",
+        "api_key": "your Groq API Key goes here",
+        "api_type": "groq"
+    },
+    {
+        "model": "llama3-8b-8192",
+        "api_key": "your Groq API Key goes here",
+        "api_type": "groq",
+        "frequency_penalty": 0.5,
+        "max_tokens": 2048,
+        "presence_penalty": 0.2,
+        "seed": 42,
+        "temperature": 0.5,
+        "top_p": 0.2
+    },
+    {
+        "model": "Mixtral 8x7b",
+        "api_key": "your Groq API Key goes here",
+        "api_type": "groq"
+    },
+    {
+        "model": "gemma-7b-it",
+        "api_key": "your Groq API Key goes here",
+        "api_type": "groq"
+    }
+]

LLMCONFIG/LLM_CONFIG_LIST.json

@@ -0,0 +1,11 @@
+[
+    {
+        "model": "Open-Orca/Mistral-7B-OpenOrca",
+        "model_client_cls": "CustomModelClient",
+        "device": "cuda",
+        "n": 1,
+        "params": {
+            "max_length": 1000
+        }
+    }
+]

LLMCONFIG/MISTRAL_AI_CONFIG_LIST.json

@@ -0,0 +1,37 @@
+[
+    {
+        "model": "open-mistral-7b",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    },
+    {
+        "model": "open-mixtral-8x7b",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    },
+    {
+        "model": "open-mixtral-8x22b",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    },
+    {
+        "model": "mistral-small-latest",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    },
+    {
+        "model": "mistral-medium-latest",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    },
+    {
+        "model": "mistral-large-latest",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    },
+    {
+        "model": "codestral-latest",
+        "api_key": "your Mistral AI API Key goes here",
+        "api_type": "mistral"
+    }
+]

LLMCONFIG/OLLAMA_LLM_CONFIG_LIST.json

@@ -0,0 +1,19 @@
+[
+    {
+        "model": "llama3.1",
+        "api_type": "ollama"
+    },
+    {
+        "model": "llama3.1:8b-instruct-q6_K",
+        "api_type": "ollama"
+    },
+    {
+        "model": "mistral-nemo",
+        "api_type": "ollama"
+    },
+    {
+        "model": "llama3.1:8b",
+        "api_type": "ollama",
+        "client_host": "http://192.168.0.1:11434"
+    }
+]

LLMHandler/llmhandler.py

@@ -0,0 +1,47 @@
+from LLMS.groqllm import GroqLLM
+
+
+class LLMHandler:
+    def __init__(self, user_controls_input):
+        self.user_control = user_controls_input
+        self.api_type = user_controls_input.get('api_type')
+
+    def handle_request(self):
+        # Dispatch to the appropriate method based on api_type
+        handler_method_name = f"{self.api_type}_handler"
+        if hasattr(self, handler_method_name):
+            handler_method = getattr(self, handler_method_name)
+            handler_method()
+        else:
+            raise ValueError(f"Unsupported API type: {self.api_type}")
+
+    def groq_handler(self):
+        obj_llm_config = GroqLLM(user_controls_input=self.user_control)
+        llm_config = obj_llm_config.groq_llm_config()
+        return llm_config
+
+    # def google_handler(self):
+    #     obj_llm_config = GoogleLLM(user_controls_input=self.user_control)
+    #     obj_llm_config.google_llm_config()
+
+    # def mistral_handler(self):
+    #     obj_llm_config = MistralLLM(user_controls_input=self.user_control)
+    #     obj_llm_config.mistral_llm_config()
+
+    # def anthropic_handler(self):
+    #     obj_llm_config = AnthropicLLM(user_controls_input=self.user_control)
+    #     obj_llm_config.anthropic_llm_config()
+
+    # def bedrock_handler(self):
+    #     obj_llm_config = BedrockLLM(user_controls_input=self.user_control)
+    #     obj_llm_config.bedrock_llm_config()
+
+    # def ollama_handler(self):
+    #     obj_llm_config = OllamaLLM(user_controls_input=self.user_control)
+    #     obj_llm_config.ollama_llm_config()
+
+    # def openai_handler(self):
+    #     obj_llm_config = OpenAILLM(user_controls_input=self.user_control)
+    #     obj_llm_config.openai_llm_config()
+
+

LLMS/groqllm.py

@@ -0,0 +1,23 @@
+import autogen
+import os
+
+import streamlit as st
+
+
+class GroqLLM:
+    def __init__(self, user_controls_input):
+        self.user_controls_input = user_controls_input
+
+    def groq_llm_config(self):
+        config_list = [
+            {
+            "api_type": 'groq',
+            "model": self.user_controls_input['selected_model_name'], 
+            "api_key": st.session_state["api_key"],
+            "cache_seed": None
+            }
+        ]
+
+        llm_config = {"config_list": config_list, "request_timeout": 60}
+        st.session_state['llm_config'] = llm_config
+        return llm_config

LLMS/llmconfig.py

@@ -0,0 +1,13 @@
+from LLMHandler.llmhandler import LLMHandler
+
+
+class LLMConfig:
+    def __init__(self,user_control):
+        self.user_control = user_control
+    def get_llm_config(self):
+        
+        user_control = self.user_control
+        handler = LLMHandler(user_control)
+        llm_config = handler.handle_request()
+        
+        return llm_config

agents/assistantagent.py

@@ -0,0 +1,14 @@
+from autogen import AssistantAgent
+import streamlit as st
+
+
+class TrackableAssistantAgent(AssistantAgent):
+    def _process_received_message(self, message, sender, silent):
+        if message and type(message)== str and sender.name =="Userproxy":
+            with st.chat_message("user"):
+                st.write(message)
+        
+                
+        return super()._process_received_message(message, sender, silent)
+
+

agents/retrieveassistantagent.py

@@ -0,0 +1,12 @@
+from autogen import AssistantAgent
+import streamlit as st
+from autogen.agentchat.contrib.retrieve_assistant_agent import RetrieveAssistantAgent
+
+
+
+class TrackableRetrieveAssistantAgent(RetrieveAssistantAgent):
+    def _process_received_message(self, message, sender, silent):
+        if type(message)== str and sender.name =="Userproxy":
+            with st.chat_message("user"):
+                st.write(message)
+        return super()._process_received_message(message, sender, silent)

agents/userproxyagent.py

@@ -0,0 +1,12 @@
+from autogen import UserProxyAgent
+import streamlit as st
+
+
+class TrackableUserProxyAgent(UserProxyAgent):
+    def _process_received_message(self, message, sender, silent):
+        with st.chat_message(sender.name.lower()):
+            if type(message)==str:
+                st.write(message)
+            else :
+                st.write(message['content'])
+        return super()._process_received_message(message, sender, silent)

app.py

@@ -0,0 +1,36 @@
+
+import streamlit as st
+from streamlitui.loadui import Streamlit_UI
+from usecases.basicexample import BasicExample
+from LLMS.llmconfig import LLMConfig
+
+# MAIN Function START
+
+
+if __name__ == "__main__":
+    
+        user_inputs_controls = Streamlit_UI().load_streamlit_ui()
+        user_inputs_display = user_inputs_controls
+        # Mask API key in displayed outputs
+        # if "api_key" in user_inputs_controls:
+        #     user_inputs_display["api_key"] = "*****"
+
+        
+        with st.sidebar:
+            # Display selected configuration
+            st.write("User Inputs:")
+            st.json(user_inputs_display)
+
+        # Basic usecasse :
+        
+        # userInput
+        problem = st.chat_input("Start Chat")
+        if problem : 
+            # LLM Configuration
+            LLMConfig(user_inputs_controls).get_llm_config()
+            if 'config_list' in st.session_state['llm_config'] : 
+                llm_config = st.session_state['llm_config']
+            obj_basic_example = BasicExample(assistant_name="Assistant", user_proxy_name='Userproxy',
+                                                        llm_config=llm_config,
+                                                        problem=problem)
+            obj_basic_example.run()

requirements.txt

@@ -0,0 +1,3 @@
+streamlit
+pyautogen==0.2.32
+groq

streamlitui/loadui.py

@@ -0,0 +1,103 @@
+import streamlit as st
+import json
+
+
+class Streamlit_UI() :
+    def __init__(self):
+        pass
+    
+        
+    # Function to load JSON files
+    def load_json(self,file_path):
+        try:
+            with open(file_path, 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            st.error(f"Error loading {file_path}: {e}")
+            return []
+    
+    
+    def load_streamlit_ui(self):
+            
+        # Load configuration files
+        anthropic_file = "./LLMCONFIG/ANTROPIC_CLAUDE_CONFIG_LIST.json"
+        google_file = "./LLMCONFIG/GOOGLE_GEMINI_CONFIG_LIST.json"
+        mistral_file = "./LLMCONFIG/MISTRAL_AI_CONFIG_LIST.json"
+        ollama_file = "./LLMCONFIG/OLLAMA_LLM_CONFIG_LIST.json"
+        groq_file = "./LLMCONFIG/GROQ_CONFIG_LIST.json"
+        bedrock_file = "./LLMCONFIG/BEDROCK_CONFIG_LIST.json"
+
+        # Load model configurations
+        anthropic_models = self.load_json(anthropic_file)
+        google_models = self.load_json(google_file)
+        mistral_models = self.load_json(mistral_file)
+        ollama_models = self.load_json(ollama_file)
+        groq_models = self.load_json(groq_file)
+        bedrock_models = self.load_json(bedrock_file)
+
+        # Combine all API types into a single dictionary
+        api_data = {
+            "anthropic": anthropic_models,
+            "bedrock": bedrock_models,
+            "google": google_models,
+            "groq": groq_models,
+            "mistral": mistral_models,
+            "ollama": ollama_models,
+            "openai": [],
+
+        }
+        user_inputs = {}
+        
+        with st.sidebar:
+
+            # Streamlit UI
+            st.title("LLM Configuraton ⚙️")
+
+            # Dropdown to select API type
+            user_inputs['api_type'] = api_type = st.selectbox("Select API Type", options=api_data.keys())
+
+            # Input handling for OpenAI
+            if api_type == "openai":
+                st.write("### Provide OpenAI Configuration Details")
+                selected_model_name = st.text_input("Enter Model Name", value="")
+                st.session_state['api_key'] = st.text_input("Enter API Key", value="", type="password")
+              
+
+                # Display selected configuration
+                st.write("### Selected Configuration")
+                st.write(f"API Type: {api_type}")
+                st.write(f"Model: {selected_model_name}")
+                st.write("User Inputs:")
+                st.json(user_inputs)
+
+            else:
+                # Get models based on selected API type
+                selected_models = api_data.get(api_type, [])
+
+                # Dropdown to select model
+                model_names = [model["model"] for model in selected_models]
+                selected_model_name = st.selectbox("Select Model", options=model_names)
+
+                # Find the selected model configuration
+                selected_model_config = next(
+                    (model for model in selected_models if model["model"] == selected_model_name), {}
+                )
+                # Input fields for the selected model configuration
+                st.write("### Provide Configuration Details")
+
+                for key, value in selected_model_config.items():
+                    if key not in ["api_type", "model"]:
+                        # Use a password field for API keys, otherwise a text input
+                        input_label = f"Enter {key}"
+                        if "key" in key.lower():
+                            st.session_state['api_key'] = user_inputs[key] = st.text_input(input_label, value="", type="password")
+                        elif isinstance(value, bool):
+                            user_inputs[key] = st.checkbox(input_label, value=value)
+                        else:
+                            user_inputs[key] = st.text_input(input_label, value=str(value))
+                            
+            user_inputs['selected_model_name']= selected_model_name 
+            
+        return user_inputs                
+            
+   

usecases/basicexample.py

@@ -0,0 +1,30 @@
+import asyncio
+from agents.assistantagent import TrackableAssistantAgent
+from agents.userproxyagent import TrackableUserProxyAgent
+import streamlit as st
+
+
+class BasicExample:
+    def __init__(self, assistant_name, user_proxy_name, llm_config, problem):
+        self.assistant = TrackableAssistantAgent(name=assistant_name,
+                                                 system_message="""you are helpful assistant. Reply "TERMINATE" in 
+                                                 the end when everything is done """,
+                                                 human_input_mode="NEVER",
+                                                 llm_config=llm_config,
+                                                 )
+        self.user_proxy = TrackableUserProxyAgent(name=user_proxy_name,
+                                                  system_message="You are Admin",
+                                                  human_input_mode="NEVER",
+                                                  llm_config=llm_config,
+                                                  code_execution_config=False,
+                                                  is_termination_msg=lambda x: x.get("content", "").strip().endswith(
+                                                      "TERMINATE"))
+        self.problem = problem
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+    async def initiate_chat(self):
+        await self.user_proxy.a_initiate_chat(self.assistant, max_turns=4,  message=self.problem)
+
+    def run(self):
+        self.loop.run_until_complete(self.initiate_chat())