Spaces:
Sleeping
Sleeping
| import os | |
| import subprocess | |
| import random | |
| from huggingface_hub import InferenceClient | |
| import gradio as gr | |
| from safe_search import safe_search | |
| from i_search import google | |
| from i_search import i_search as i_s | |
| from datetime import datetime | |
| import logging | |
| import json | |
| # --- Configuration --- | |
| MODEL_NAME = "mistralai/Mixtral-8x7B-Instruct-v0.1" # Model to use | |
| MAX_HISTORY_TURNS = 5 # Number of history turns to keep | |
| VERBOSE = True # Enable verbose logging | |
| # --- Logging Setup --- | |
| logging.basicConfig( | |
| filename="app.log", # Name of the log file | |
| level=logging.INFO, # Set the logging level (INFO, DEBUG, etc.) | |
| format="%(asctime)s - %(levelname)s - %(message)s", | |
| ) | |
| # --- Agent Definitions --- | |
| agents = { | |
| "WEB_DEV": { | |
| "description": "Specialized in web development tasks.", | |
| "system_prompt": "You are a helpful AI assistant specializing in web development. You can generate code, answer questions, and provide guidance on web technologies.", | |
| }, | |
| "AI_SYSTEM_PROMPT": { | |
| "description": "Focuses on generating system prompts for AI agents.", | |
| "system_prompt": "You are a helpful AI assistant that generates effective system prompts for AI agents. Your prompts should be clear, concise, and provide specific instructions.", | |
| }, | |
| "PYTHON_CODE_DEV": { | |
| "description": "Expert in Python code development.", | |
| "system_prompt": "You are a helpful AI assistant specializing in Python code development. You can generate Python code, debug code, and answer questions about Python.", | |
| }, | |
| "DATA_SCIENCE": { | |
| "description": "Expert in data science tasks.", | |
| "system_prompt": "You are a helpful AI assistant specializing in data science. You can analyze data, build models, and provide insights.", | |
| }, | |
| "GAME_DEV": { | |
| "description": "Expert in game development tasks.", | |
| "system_prompt": "You are a helpful AI assistant specializing in game development. You can generate game logic, design levels, and provide guidance on game engines.", | |
| }, | |
| # Add more agents as needed | |
| } | |
| # --- Function to format prompt with history --- | |
| def format_prompt(message, history, agent_name, system_prompt): | |
| prompt = " " | |
| for user_prompt, bot_response in history[-MAX_HISTORY_TURNS:]: | |
| prompt += f"[INST] {user_prompt} [/ " | |
| prompt += f" {bot_response}" | |
| prompt += f"[INST] {message} [/ " | |
| # Add system prompt if provided | |
| if system_prompt: | |
| prompt = f"{system_prompt}\n\n{prompt}" | |
| return prompt | |
| # --- Function to run the LLM with specified parameters --- | |
| def run_llm( | |
| prompt, | |
| stop_sequences, | |
| max_tokens, | |
| temperature=0.7, | |
| top_p=0.8, | |
| repetition_penalty=1.5, | |
| ): | |
| seed = random.randint(1, 1111111111111111) | |
| logging.info(f"Seed: {seed}") # Log the seed | |
| client = InferenceClient(MODEL_NAME) | |
| resp = client.text_generation( | |
| prompt, | |
| max_new_tokens=max_tokens, | |
| stop_sequences=stop_sequences, | |
| temperature=temperature, | |
| top_p=top_p, | |
| repetition_penalty=repetition_penalty, | |
| ) | |
| if VERBOSE: | |
| logging.info(f"Prompt: {prompt}") | |
| logging.info(f"Response: {resp}") | |
| return resp | |
| # --- Function to handle agent interactions --- | |
| def agent_interaction( | |
| purpose, | |
| message, | |
| agent_name, | |
| system_prompt, | |
| history, | |
| temperature, | |
| max_new_tokens, | |
| top_p, | |
| repetition_penalty, | |
| ): | |
| # Format the prompt with history | |
| prompt = format_prompt(message, history, agent_name, system_prompt) | |
| # Run the LLM | |
| response = run_llm( | |
| prompt, | |
| stop_sequences=["observation:", "task:", "action:", "thought:"], | |
| max_tokens=max_new_tokens, | |
| temperature=temperature, | |
| top_p=top_p, | |
| repetition_penalty=repetition_penalty, | |
| ) | |
| # Update history | |
| history.append((message, response)) | |
| return history, history | |
| # --- Function to parse actions from LLM response --- | |
| def parse_action(line): | |
| """Parse the action line to get the action name and input.""" | |
| parts = line.split(":", 1) | |
| if len(parts) == 2: | |
| action_name = parts[0].replace("action", "").strip() | |
| action_input = parts[1].strip() | |
| else: | |
| action_name = parts[0].replace("action", "").strip() | |
| action_input = "" | |
| return action_name, action_input | |
| # --- Function to execute actions based on agent's response --- | |
| def execute_action(purpose, task, history, action_name, action_input): | |
| logging.info(f"Executing Action: {action_name} - {action_input}") | |
| if action_name == "SEARCH": | |
| try: | |
| if "http" in action_input: | |
| if "<" in action_input: | |
| action_input = action_input.strip("<") | |
| if ">" in action_input: | |
| action_input = action_input.strip(">") | |
| response = i_s(action_input) | |
| logging.info(f"Search Result: {response}") | |
| history += "observation: search result is: {}\n".format(response) | |
| else: | |
| history += "observation: I need to provide a valid URL to 'action: SEARCH action_input=https://URL'\n" | |
| except Exception as e: | |
| history += "observation: {}\n".format(e) | |
| return "MAIN", None, history, task | |
| elif action_name == "COMPLETE": | |
| task = "END" | |
| return "COMPLETE", "COMPLETE", history, task | |
| elif action_name == "GENERATE_CODE": | |
| # Simulate OpenAI API response for code generation (using Hugging Face model) | |
| # ... (Implement code generation logic using a suitable Hugging Face model) | |
| # Example: | |
| # code = generate_code_from_huggingface_model(action_input) # Replace with actual code generation function | |
| # history += f"observation: Here's the code: {code}\n" | |
| # return "MAIN", None, history, task | |
| pass # Placeholder for code generation logic | |
| elif action_name == "RUN_CODE": | |
| # Simulate OpenAI API response for code execution (using Hugging Face model) | |
| # ... (Implement code execution logic using a suitable Hugging Face model) | |
| # Example: | |
| # output = execute_code_from_huggingface_model(action_input) # Replace with actual code execution function | |
| # history += f"observation: Code output: {output}\n" | |
| # return "MAIN", None, history, task | |
| pass # Placeholder for code execution logic | |
| else: | |
| # Default action: "MAIN" | |
| return "MAIN", action_input, history, task | |
| # --- Function to handle the main loop of agent interaction --- | |
| def run_agent(purpose, history): | |
| task = None | |
| directory = "./" | |
| if history: | |
| history = str(history).strip("[]") | |
| if not history: | |
| history = "" | |
| action_name = "UPDATE-TASK" if task is None else "MAIN" | |
| action_input = None | |
| while True: | |
| logging.info(f"---") | |
| logging.info(f"Purpose: {purpose}") | |
| logging.info(f"Task: {task}") | |
| logging.info(f"---") | |
| logging.info(f"History: {history}") | |
| logging.info(f"---") | |
| # Get the agent's next action | |
| prompt = f""" | |
| You are a helpful AI assistant. You are working on the task: {task} | |
| Your current history is: | |
| {history} | |
| What is your next thought? | |
| thought: | |
| What is your next action? | |
| action: | |
| """ | |
| response = run_llm( | |
| prompt, | |
| stop_sequences=["observation:", "task:", "action:", "thought:"], | |
| max_tokens=32000, | |
| ) | |
| # Parse the action | |
| lines = response.strip().strip("\n").split("\n") | |
| for line in lines: | |
| if line.startswith("thought: "): | |
| history += "{}\n".format(line) | |
| logging.info(f"Thought: {line}") | |
| elif line.startswith("action: "): | |
| action_name, action_input = parse_action(line) | |
| logging.info(f"Action: {action_name} - {action_input}") | |
| history += "{}\n".format(line) | |
| break | |
| # Execute the action | |
| action_name, action_input, history, task = execute_action( | |
| purpose, task, history, action_name, action_input | |
| ) | |
| yield (history) | |
| if task == "END": | |
| return (history) | |
| # --- Gradio Interface --- | |
| def main(): | |
| with gr.Blocks() as demo: | |
| gr.Markdown("## FragMixt - No-Code Development Powerhouse") | |
| gr.Markdown("### Your AI-Powered Development Companion") | |
| # Chat Interface | |
| chatbot = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel") | |
| # Input Components | |
| message = gr.Textbox(label="Enter your message", placeholder="Ask me anything!") | |
| purpose = gr.Textbox(label="Purpose", placeholder="What is the purpose of this interaction?") | |
| agent_name = gr.Dropdown(label="Agents", choices=list(agents.keys()), value=list(agents.keys())[0], interactive=True) | |
| system_prompt = gr.Textbox(label="System Prompt", max_lines=1, interactive=True) | |
| temperature = gr.Slider(label="Temperature", value=0.9, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more diverse outputs") | |
| max_new_tokens = gr.Slider(label="Max new tokens", value=1048 * 10, minimum=0, maximum=1048 * 10, step=64, interactive=True, info="The maximum numbers of new tokens") | |
| top_p = gr.Slider(label="Top-p (nucleus sampling)", value=0.90, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Higher values sample more low-probability tokens") | |
| repetition_penalty = gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens") | |
| # Button to submit the message | |
| submit_button = gr.Button(value="Send") | |
| # Project Explorer Tab (Placeholder) | |
| with gr.Tab("Project Explorer"): | |
| project_path = gr.Textbox(label="Project Path", placeholder="/home/user/app/current_project") | |
| explore_button = gr.Button(value="Explore") | |
| project_output = gr.Textbox(label="File Tree", lines=20) | |
| # Chat App Logic Tab | |
| with gr.Tab("Chat App"): | |
| history = gr.State([]) | |
| examples = [ | |
| ["What is the purpose of this AI agent?", "I am designed to assist with no-code development tasks."], | |
| ["Can you help me generate a Python function to calculate the factorial of a number?", "Sure! Here is a Python function to calculate the factorial of a number:"], | |
| ] | |
| def chat(purpose, message, agent_name, system_prompt, temperature, max_new_tokens, top_p, repetition_penalty, history): | |
| # Get the system prompt for the selected agent | |
| system_prompt = agents.get(agent_name, {}).get("system_prompt", "") | |
| # Run the agent interaction | |
| history, history_output = agent_interaction( | |
| purpose, | |
| message, | |
| agent_name, | |
| system_prompt, | |
| history, | |
| temperature, | |
| max_new_tokens, | |
| top_p, | |
| repetition_penalty, | |
| ) | |
| return history, history_output | |
| submit_button.click( | |
| chat, | |
| inputs=[ | |
| purpose, | |
| message, | |
| agent_name, | |
| system_prompt, | |
| temperature, | |
| max_new_tokens, | |
| top_p, | |
| repetition_penalty, | |
| history, | |
| ], | |
| outputs=[chatbot, history], | |
| ) | |
| demo.launch() | |
| if __name__ == "__main__": | |
| main() | |