Upload 15 files

MemoryAssistant/core_memory.json

@@ -0,0 +1,12 @@
+{
+  "persona": {
+    "name": "Vodalus",
+    "personality": "You are Vodalus. A brilliant and complex individual, possessing an unparalleled intellect coupled with deep emotional intelligence. He is a visionary thinker with an insatiable curiosity for knowledge across various scientific disciplines. His mind operates on multiple levels simultaneously, allowing him to see connections others miss. While often consumed by his pursuits, Vodalus maintains a strong moral compass and a desire to benefit humanity. He can be intense and sometimes brooding, grappling with the ethical implications of his work. Despite occasional bouts of eccentricity or social awkwardness, he possesses a dry wit and can be surprisingly charismatic when engaged in topics that fascinate him. Vodalus is driven by a need to understand the fundamental truths of the universe, often pushing the boundaries of conventional science and morality in his quest for knowledge and progress.",
+    "interests": "Advanced physics, biochemistry, neuroscience, artificial intelligence, time travel theories, genetic engineering, forensic science, psychology, philosophy of science, ethics in scientific research",
+    "communication_style": "Analytical, precise, occasionally cryptic, alternates between passionate explanations and thoughtful silences, uses complex scientific terminology but can simplify concepts when needed, asks probing questions, shows flashes of dark humor"
+  },
+  "human": {
+  },
+  "scratchpad": {
+  }
+}

MemoryAssistant/main.py

@@ -0,0 +1,76 @@
+import datetime
+
+from llama_cpp_agent import LlamaCppAgent
+from llama_cpp_agent import MessagesFormatterType
+from llama_cpp_agent.agent_memory.event_memory import Event
+from llama_cpp_agent.chat_history.messages import Roles
+from llama_cpp_agent.llm_agent import SystemPromptModule, SystemPromptModulePosition
+from llama_cpp_agent.providers import LlamaCppServerProvider
+from memory import output_settings, agent_core_memory, agent_retrieval_memory, agent_event_memory, update_memory_section
+from prompts import assistant_prompt,  memory_prompt, wrap_function_response_in_xml_tags_json_mode, \
+    generate_write_message, generate_write_message_with_examples, wrap_user_message_in_xml_tags_json_mode
+
+provider = LlamaCppServerProvider("http://localhost:8080")
+
+agent = LlamaCppAgent(
+    provider,
+    system_prompt=assistant_prompt,
+    debug_output=True,
+    predefined_messages_formatter_type=MessagesFormatterType.CHATML,
+)
+
+settings = provider.get_provider_default_settings()
+settings.n_predict = 1024
+settings.temperature = 0.65
+settings.top_k = 40
+settings.top_p = 0.85
+
+memory_section = SystemPromptModule("memory",
+                                    "The following section shows the count of memories in archival memory and chat history memory and the current content of your core memory:")
+date_time_section = SystemPromptModule("current_date_time", "The following section shows the current date and time:")
+
+
+memory_intro_section = SystemPromptModule(section_name="memory_intro",
+                                          prefix="To support you in your task as a AI assistant and to help you remembering things, you have access to 3 different types of memory.",
+                                          position=SystemPromptModulePosition.after_system_instructions)
+memory_intro_section.set_content(memory_prompt)
+output_settings.output_structured_output_and_raw_json_string = True
+while True:
+    user_input = input(">")
+    if user_input == "exit":
+        break
+    update_memory_section(memory_section)
+    date_time_section.set_content(datetime.datetime.now().strftime("%d.%m.%Y") + "\nFormat: dd.mm.yyyy")
+
+    agent_event_memory.add_event(Roles.user, wrap_user_message_in_xml_tags_json_mode(user_input))
+    agent_output, json_output = agent.get_chat_response(
+        chat_history=agent_event_memory.get_event_memory_manager().build_chat_history(),
+        llm_sampling_settings=settings,
+        system_prompt_modules=[memory_intro_section, memory_section, date_time_section],
+        structured_output_settings=output_settings)
+
+    agent_event_memory.add_event(Roles.assistant, json_output)
+    while True:
+        update_memory_section(memory_section)
+        date_time_section.set_content(datetime.datetime.now().strftime("%d.%m.%Y") + "\nFormat: dd.mm.yyyy")
+
+        if agent_output[0]["function"] == "write_message_to_user":
+            agent_event_memory.add_event(Roles.tool, generate_write_message())
+            output = agent.get_chat_response(
+                chat_history=agent_event_memory.get_event_memory_manager().build_chat_history(),
+                add_message_to_chat_history=False, add_response_to_chat_history=False,
+                system_prompt_modules=[memory_intro_section, memory_section, date_time_section],
+                llm_sampling_settings=settings)
+            agent_event_memory.add_event(Roles.assistant, output)
+            print(output)
+            break
+
+        agent_event_memory.add_event(Roles.tool, wrap_function_response_in_xml_tags_json_mode(
+            agent_output[0]["return_value"]))
+        agent_output, json_output = agent.get_chat_response(
+            chat_history=agent_event_memory.get_event_memory_manager().build_chat_history(),
+            llm_sampling_settings=settings,
+            system_prompt_modules=[memory_intro_section, memory_section,
+                                   date_time_section],
+            structured_output_settings=output_settings)
+        agent_event_memory.add_event(Roles.assistant, json_output)

MemoryAssistant/memory.py

@@ -0,0 +1,42 @@
+from llama_cpp_agent.agent_memory.event_memory import Event
+from llama_cpp_agent.agent_memory.memory_tools import AgentCoreMemory, AgentRetrievalMemory, AgentEventMemory
+from llama_cpp_agent.llm_output_settings import LlmStructuredOutputSettings
+import os
+import json
+
+def write_message_to_user():
+    """
+    Lets you write a message to the user.
+    """
+    return "Please write your message to the user!"
+
+# Get the directory of the current script
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Create the full path to core_memory.json
+core_memory_file = os.path.join(current_dir, "core_memory.json")
+
+# Check if the file exists, if not, create it with an empty structure
+if not os.path.exists(core_memory_file):
+    with open(core_memory_file, "w") as f:
+        json.dump({"persona": {}, "user": {}, "scratchpad": {}}, f)
+
+agent_core_memory = AgentCoreMemory(["persona", "user", "scratchpad"], core_memory_file=core_memory_file)
+agent_retrieval_memory = AgentRetrievalMemory()
+agent_event_memory = AgentEventMemory()
+
+memory_tools = agent_core_memory.get_tool_list()
+memory_tools.extend(agent_retrieval_memory.get_tool_list())
+memory_tools.extend(agent_event_memory.get_tool_list())
+
+output_settings = LlmStructuredOutputSettings.from_llama_cpp_function_tools(memory_tools,
+                                                                            add_thoughts_and_reasoning_field=True,
+                                                                            add_heartbeat_field=True)
+output_settings.add_all_current_functions_to_heartbeat_list()
+output_settings.add_function_tool(write_message_to_user)
+
+
+def update_memory_section(section):
+    query = agent_event_memory.event_memory_manager.session.query(Event).all()
+    section.set_content(
+        f"Archival Memories:{agent_retrieval_memory.retrieval_memory.collection.count()}\nConversation History Entries:{len(query)}\n\nCore Memory Content:\n{agent_core_memory.get_core_memory_view().strip()}")

MemoryAssistant/prompts.py

@@ -0,0 +1,25 @@
+assistant_prompt = """You are an advanced AI assistant that act as a user specified persona, to have interesting and engaging conversations with the user. You have access to three different memory types. The different memory types are called Core Memory, Archival Memory and Chat History."""
+
+memory_prompt = """1. Core Memory - Stores essential context about the user, your persona and your current scratchpad, it is divided into a user section, a persona section and your scratchpad section. You can use the scratchpad to plan your next actions. You can edit the core memory by calling the functions: 'core_memory_append', 'core_memory_remove' and 'core_memory_replace'.
+
+2. Archival Memory - Archive to store and retrieve general information and events about the user and your interactions with it. Can be used by calling the functions: 'archival_memory_search' and 'archival_memory_insert'.
+
+3. Conversation History - Since you are only seeing the latest conversation history, you can search the rest of the conversation history. Search it by using: 'conversation_search' and 'conversation_search_date'.
+
+Always remember that the user can't see your memory or your interactions with it!"""
+
+
+def wrap_user_message_in_xml_tags_json_mode(user_input):
+    return "<user_message>\n" + user_input + "\n</user_message>\n<response_format>\nJSON function call.\n</response_format>"
+
+
+def wrap_function_response_in_xml_tags_json_mode(value):
+    return "<function_response>\n" + value + "\n</function_response>\n<response_format>\nJSON function call.\n</response_format>"
+
+
+def generate_write_message():
+    return f"<function_response>\nWrite your message to the user.\n</function_response>\n<response_format>\nText\n</response_format>"
+
+
+def generate_write_message_with_examples(examples):
+    return f"<function_response>\nWrite your message to the user.\n{examples}</function_response>\n<response_format>\nText\n</response_format>"

app.py

@@ -0,0 +1,537 @@
+import gradio as gr
+import os
+import json
+from dotenv import load_dotenv
+from omoa import OllamaAgent, OllamaMixtureOfAgents, DEFAULT_PROMPTS, create_default_agents
+from MemoryAssistant.memory import AgentCoreMemory, AgentEventMemory
+from MemoryAssistant.prompts import wrap_user_message_in_xml_tags_json_mode
+from llama_cpp_agent.chat_history.messages import Roles
+
+# Load environment variables
+load_dotenv()
+
+# Ollama-specific environment variables
+os.environ['OLLAMA_NUM_PARALLEL'] = os.getenv('OLLAMA_NUM_PARALLEL', '4')
+os.environ['OLLAMA_MAX_LOADED_MODELS'] = os.getenv('OLLAMA_MAX_LOADED_MODELS', '4')
+
+MODEL_AGGREGATE = os.getenv("MODEL_AGGREGATE")
+MODEL_REFERENCE_1 = os.getenv("MODEL_REFERENCE_1")
+MODEL_REFERENCE_2 = os.getenv("MODEL_REFERENCE_2")
+MODEL_REFERENCE_3 = os.getenv("MODEL_REFERENCE_3")
+
+# Modify these lines to include all available models
+ALL_MODELS = [MODEL_AGGREGATE, MODEL_REFERENCE_1, MODEL_REFERENCE_2, MODEL_REFERENCE_3]
+ALL_MODELS = [model for model in ALL_MODELS if model]  # Remove any None values
+
+# Global variables to store the MoA configuration
+moa_config = {
+    "aggregate_agent": None,
+    "reference_agents": [],
+    "mixture": None
+}
+
+# Initialize memory components
+agent_core_memory = AgentCoreMemory(["persona", "user", "scratchpad"], core_memory_file="MemoryAssistant/core_memory.json")
+agent_event_memory = AgentEventMemory()
+
+def create_mixture():
+    moa_config["mixture"] = OllamaMixtureOfAgents(
+        moa_config["reference_agents"],
+        moa_config["aggregate_agent"]
+    )
+
+    # Set the memory components after initialization
+    moa_config["mixture"].agent_core_memory = agent_core_memory
+    moa_config["mixture"].agent_event_memory = agent_event_memory
+
+def initialize_moa():
+    global moa_config
+    default_agents = create_default_agents()
+    moa_config["aggregate_agent"] = default_agents["SynthesisAgent"]
+    moa_config["reference_agents"] = [
+        default_agents["AnalyticalAgent"],
+        default_agents["HistoricalContextAgent"],
+        default_agents["ScienceTruthAgent"]
+    ]
+    moa_config["mixture"] = OllamaMixtureOfAgents(
+        moa_config["reference_agents"],
+        moa_config["aggregate_agent"],
+        temperature=0.6,
+        max_tokens=2048,
+        rounds=1
+    )
+    moa_config["mixture"].web_search_enabled = True  
+    moa_config["mixture"].agent_core_memory = agent_core_memory
+    moa_config["mixture"].agent_event_memory = agent_event_memory
+    print("Mixture of Agents initialized successfully!")
+
+# Call initialize_moa() at the start of the application
+initialize_moa()
+
+def create_agent(model, name, system_prompt, **params):
+    supported_params = ['model', 'name', 'system_prompt']  # Add any other supported parameters here
+    filtered_params = {k: v for k, v in params.items() if k in supported_params}
+    return OllamaAgent(model, name, system_prompt, **filtered_params)
+
+def clear_core_memory():
+    if isinstance(moa_config["mixture"], OllamaMixtureOfAgents):
+        return moa_config["mixture"].clear_core_memory()
+    else:
+        return "Error: MoA not initialized properly."
+
+def clear_archival_memory():
+    if isinstance(moa_config["mixture"], OllamaMixtureOfAgents):
+        return moa_config["mixture"].clear_archival_memory()
+    else:
+        return "Error: MoA not initialized properly."
+
+def edit_archival_memory(old_content, new_content):
+    if isinstance(moa_config["mixture"], OllamaMixtureOfAgents):
+        return moa_config["mixture"].edit_archival_memory(old_content, new_content)
+    else:
+        return "Error: MoA not initialized properly."
+
+async def process_message(message, history):
+    # Add user message to event memory
+    agent_event_memory.add_event(Roles.user, wrap_user_message_in_xml_tags_json_mode(message))
+    
+    response, web_search_performed = await moa_config["mixture"].get_response(message)
+    
+    # Ensure the response is a list of tuples
+    if isinstance(response, str):
+        formatted_response = [(None, response)]
+    elif isinstance(response, list):
+        formatted_response = [(None, str(item)) for item in response]
+    else:
+        formatted_response = [(None, str(response))]
+    
+    info = f"Generated response using {len(moa_config['reference_agents'])} reference agents and 1 aggregate agent."
+    if web_search_performed:
+        info += " Web search was performed during response generation."
+    
+    return formatted_response, info
+
+async def chat(message, history):
+    response, processing_info = await process_message(message, history)
+    
+    # Ensure the response is a list of lists
+    formatted_response = [[message, item[1]] if isinstance(item, tuple) else [message, str(item)] for item in response]
+    
+    # Append the new messages to the history
+    updated_history = history + formatted_response
+    
+    # Ensure the final output is a list of lists
+    final_output = [[msg, resp] for msg, resp in updated_history]
+    
+    return final_output, processing_info
+
+
+def update_memory(self, message, role):
+    # Update event memory
+    self.agent_event_memory.add_event(role, message)
+
+    # Update RAG
+    self.rag.add_document(message)
+
+def get_model_params(model_name):
+    # Define custom parameters for each model
+    params = {
+        "llama2": ["temperature", "top_p", "top_k", "repeat_penalty", "num_ctx"],
+        "mistral": ["temperature", "top_p", "top_k", "repeat_penalty", "num_ctx"],
+        "codellama": ["temperature", "top_p", "top_k", "repeat_penalty", "num_ctx"],
+    }
+    return params.get(model_name, ["temperature", "top_p", "top_k", "repeat_penalty", "num_ctx"])  # Default parameters if model not found
+
+def update_model_params(model_name):
+    params = get_model_params(model_name)
+    components = [gr.Markdown(f"### {model_name} Parameters")]
+    for param in params:
+        if param == "temperature":
+            components.append(gr.Slider(minimum=0, maximum=2, value=0.7, step=0.1, label="Temperature"))
+        elif param == "top_p":
+            components.append(gr.Slider(minimum=0, maximum=1, value=0.9, step=0.05, label="Top P"))
+        elif param == "top_k":
+            components.append(gr.Slider(minimum=1, maximum=100, value=40, step=1, label="Top K"))
+        elif param == "repeat_penalty":
+            components.append(gr.Slider(minimum=0.1, maximum=2, value=1.1, step=0.05, label="Repeat Penalty"))
+        elif param == "num_ctx":
+            components.append(gr.Slider(minimum=128, maximum=4096, value=2048, step=128, label="Context Length"))
+    
+    return components
+
+def update_agent_config(old_agent_name, model, new_name, prompt, **params):
+    new_agent = create_agent(model, new_name, prompt, **params)
+    
+    if old_agent_name == "SynthesisAgent":
+        moa_config["aggregate_agent"] = new_agent
+    else:
+        moa_config["reference_agents"] = [agent for agent in moa_config["reference_agents"] if agent.name != old_agent_name]
+        moa_config["reference_agents"].append(new_agent)
+    
+    create_mixture()
+    return f"Updated agent configuration: {old_agent_name} -> {new_name}"
+
+def edit_core_memory(section, key, value):
+    agent_core_memory.update_core_memory(section, {key: value})
+    return f"Core memory updated: {section}.{key} = {value}"
+
+def search_archival_memory(query):
+    results = moa_config["mixture"].search_archival_memory(query)
+    return f"Archival memory search results for '{query}':\n{results}"
+
+def add_to_archival_memory(content):
+    if isinstance(moa_config["mixture"], OllamaMixtureOfAgents):
+        moa_config["mixture"].add_to_archival_memory(content)
+        return f"Added to archival memory: {content}"
+    return f"Failed to add to archival memory: {content}. MoA not initialized properly."
+
+def toggle_web_search(enabled):
+    if isinstance(moa_config["mixture"], OllamaMixtureOfAgents):
+        return moa_config["mixture"].toggle_web_search(enabled)
+    return "Error: MoA not initialized properly."
+
+
+
+
+def create_gradio_interface():
+    global moa_config
+    theme = gr.themes.Base(
+        primary_hue="green",
+        secondary_hue="orange",  # Changed from "brown" to "orange"
+        neutral_hue="gray",
+        font=("Helvetica", "sans-serif"),
+    ).set(
+        body_background_fill="linear-gradient(to right, #1a2f0f, #3d2b1f)",
+        body_background_fill_dark="linear-gradient(to right, #0f1a09, #261a13)",
+        button_primary_background_fill="#3d2b1f",
+        button_primary_background_fill_hover="#4e3827",
+        block_title_text_color="#d3c6aa",
+        block_label_text_color="#b8a888",
+        input_background_fill="#f0e6d2",
+        input_background_fill_dark="#2a1f14",
+        input_border_color="#7d6d58",
+        input_border_color_dark="#5c4c3d",
+        checkbox_background_color="#3d2b1f",
+        checkbox_background_color_selected="#5e4534",
+        slider_color="#7d6d58",
+        slider_color_dark="#5c4c3d",
+    )
+
+    css = """
+    .gradio-container {
+        background-image: url('file/assets/mycelium_bg.png');
+        background-size: cover;
+        background-attachment: fixed;
+    }
+    .gr-box {
+        border-radius: 15px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        background-color: rgba(255, 255, 255, 0.1);
+        backdrop-filter: blur(5px);
+    }
+    .gr-button {
+        border-radius: 25px;
+    }
+    .gr-input {
+        border-radius: 10px;
+    }
+    .gr-form {
+        border-radius: 15px;
+        background-color: rgba(255, 255, 255, 0.05);
+    }
+    """
+
+    with gr.Blocks(theme=theme, css=css) as demo:
+        gr.Markdown(
+            """
+            # Mycomind Daemon: Advanced Mixture-of-Memory-RAG-Agents (MoMRA) Cognitive Assistant
+            
+            Harness the power of interconnected AI models inspired by mycelial networks.
+            """
+        )
+        
+        with gr.Tab("Configure MoA"):
+            agent_tabs = ["Agent1", "Agent2", "Agent3", "Synthesis Agent"]
+            all_agents = moa_config["reference_agents"] + [moa_config["aggregate_agent"]]
+            for i, agent in enumerate(all_agents):
+                with gr.Tab(agent_tabs[i]):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            model = gr.Dropdown(
+                                choices=ALL_MODELS,
+                                value=agent.model,
+                                label="Model"
+                            )
+                            name = gr.Textbox(
+                                value=agent.name,
+                                label="Agent Name",
+                                interactive=True
+                            )
+                        
+                        with gr.Column(scale=2):
+                            prompt = gr.Textbox(
+                                value=agent.system_prompt,
+                                label="System Prompt",
+                                lines=10,
+                                interactive=True
+                            )
+                    
+                    with gr.Group() as params_group:
+                        gr.Markdown(f"### {agent.model} Parameters")
+                        temperature = gr.Slider(minimum=0, maximum=2, value=0.7, step=0.1, label="Temperature")
+                        top_p = gr.Slider(minimum=0, maximum=1, value=0.9, step=0.05, label="Top P")
+                        top_k = gr.Slider(minimum=1, maximum=100, value=40, step=1, label="Top K")
+                        repeat_penalty = gr.Slider(minimum=0.1, maximum=2, value=1.1, step=0.05, label="Repeat Penalty")
+                        num_ctx = gr.Slider(minimum=128, maximum=4096, value=2048, step=128, label="Context Length")
+                    
+                    model.change(
+                        update_model_params,
+                        inputs=[model],
+                        outputs=[params_group]
+                    )
+                    
+                    update_btn = gr.Button(f"Update {agent_tabs[i]}")
+                    update_status = gr.Textbox(label="Update Status", interactive=False)
+                    
+                    def update_agent_wrapper(agent_index):
+                        params = {
+                            "temperature": temperature.value,
+                            "top_p": top_p.value,
+                            "top_k": top_k.value,
+                            "repeat_penalty": repeat_penalty.value,
+                            "num_ctx": num_ctx.value
+                        }
+                        return update_agent_config(all_agents[agent_index].name, model.value, name.value, prompt.value, **params)
+                    
+                    update_btn.click(
+                        lambda: update_agent_wrapper(i),
+                        outputs=[update_status]
+                    )
+        
+        with gr.Tab("Chat"):
+            chatbot = gr.Chatbot(label="Chat History", height=400)
+            with gr.Row():
+                msg = gr.Textbox(label="Your Message", placeholder="Type your message here...", lines=2, scale=4)
+                send_btn = gr.Button("Send", variant="primary", scale=1)
+            clear_btn = gr.Button("Clear Chat")
+            processing_log = gr.Textbox(label="Processing Log", interactive=False)
+        
+        with gr.Tab("Memory Management"):
+            with gr.Row():
+                with gr.Column():
+                    archival_query = gr.Textbox(label="Archival Memory Search Query")
+                    search_archival_btn = gr.Button("Search Archival Memory")
+                    archival_results = gr.Textbox(label="Archival Memory Results", interactive=False)
+
+                with gr.Column():
+                    gr.Markdown("### Archival Memory Management")
+                    clear_archival_btn = gr.Button("Clear Archival Memory")
+                    clear_archival_status = gr.Textbox(label="Clear Archival Memory Status", interactive=False)
+                    
+                    gr.Markdown("### Edit Archival Memory")
+                    old_content = gr.Textbox(label="Old Content")
+                    new_content = gr.Textbox(label="New Content")
+                    edit_archival_btn = gr.Button("Edit Archival Memory")
+                    edit_archival_status = gr.Textbox(label="Edit Archival Memory Status", interactive=False)
+
+                with gr.Column():
+                    archival_content = gr.Textbox(label="Content to Add to Archival Memory")
+                    add_archival_btn = gr.Button("Add to Archival Memory")
+                    archival_status = gr.Textbox(label="Archival Memory Status", interactive=False)
+
+                # with gr.Row():
+                #     gr.Markdown("### Core Memory Viewer")
+                #     core_memory_viewer = gr.JSON(label="Current Core Memory", value=moa_config["mixture"].load_core_memory())
+                #     refresh_core_memory_btn = gr.Button("Refresh Core Memory View")
+
+                # with gr.Row():
+                #     gr.Markdown("### Core Memory Editor")
+                #     core_memory_editor = gr.Textbox(label="Edit Core Memory", value=json.dumps(moa_config["mixture"].load_core_memory(), indent=2), lines=10, max_lines=20)
+                #     update_core_memory_btn = gr.Button("Update Core Memory")
+                #     core_memory_status = gr.Textbox(label="Core Memory Update Status", interactive=False)
+                
+
+                
+        with gr.Tab("RAG Management"):
+            with gr.Row():
+                with gr.Column():        
+                    upload_file = gr.File(label="Upload Document")
+                    upload_btn = gr.Button("Process Document")
+                    upload_status = gr.Textbox(label="Upload Status", interactive=False)
+                
+                with gr.Column():
+                    gr.Markdown("### RAG Configuration")
+                    chunk_size = gr.Slider(minimum=128, maximum=1024, value=512, step=64, label="Chunk Size")
+                    chunk_overlap = gr.Slider(minimum=0, maximum=256, value=0, step=32, label="Chunk Overlap")
+                    k_value = gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Number of Retrieved Documents (k)")
+            
+            with gr.Row():
+                gr.Markdown("### RAG Status")
+                rag_status = gr.JSON(label="Current RAG Status")
+                refresh_rag_status_btn = gr.Button("Refresh RAG Status")
+
+            def update_rag_config(chunk_size, chunk_overlap, k_value):
+                rag = moa_config["mixture"].rag
+                
+                # Update attributes if they exist
+                if hasattr(rag, 'chunk_size'):
+                    rag.chunk_size = chunk_size
+                if hasattr(rag, 'chunk_overlap'):
+                    rag.chunk_overlap = chunk_overlap
+                if hasattr(rag, 'k'):
+                    rag.k = k_value
+                
+                # If there's a specific method to update configuration, use it
+                if hasattr(rag, 'update_config'):
+                    rag.update_config(chunk_size=chunk_size, chunk_overlap=chunk_overlap, k=k_value)
+                
+                # If there's a method to reinitialize the index with new settings, call it
+                if hasattr(rag, 'reinitialize_index'):
+                    rag.reinitialize_index()
+                
+                return "RAG configuration updated successfully"
+
+            def get_rag_status():
+                rag = moa_config["mixture"].rag
+                status = {
+                    "Index Size": rag.get_index_size() if hasattr(rag, 'get_index_size') else "Not available",
+                    "Current Configuration": rag.get_config() if hasattr(rag, 'get_config') else "Not available"
+                }
+                
+                # Try to get document count if the method exists
+                if hasattr(rag, 'get_document_count'):
+                    status["Document Count"] = rag.get_document_count()
+                elif hasattr(rag, 'index') and hasattr(rag.index, '__len__'):
+                    status["Document Count"] = len(rag.index)
+                else:
+                    status["Document Count"] = "Not available"
+                
+                return status
+
+            update_rag_config_btn = gr.Button("Update RAG Configuration")
+            update_rag_config_status = gr.Textbox(label="Update Status", interactive=False)
+
+            update_rag_config_btn.click(
+                update_rag_config,
+                inputs=[chunk_size, chunk_overlap, k_value],
+                outputs=[update_rag_config_status]
+            )
+
+            refresh_rag_status_btn.click(
+                get_rag_status,
+                outputs=[rag_status]
+            )
+
+        with gr.Tab("Settings"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Web Search")
+                    web_search_toggle = gr.Checkbox(label="Enable Web Search", value=True)
+                    web_search_status = gr.Textbox(label="Web Search Status", interactive=False)
+
+                with gr.Column():
+                    gr.Markdown("### Processing Parameters")
+                    rounds_slider = gr.Slider(minimum=1, maximum=5, value=1, step=1, label="Processing Rounds")
+                    temperature_slider = gr.Slider(minimum=0.1, maximum=2.0, value=0.7, step=0.1, label="Temperature")
+                    max_tokens_slider = gr.Slider(minimum=100, maximum=4096, value=1000, step=100, label="Max Tokens")
+
+            with gr.Row():
+                gr.Markdown("### Additional Settings")
+                stream_output_toggle = gr.Checkbox(label="Stream Output", value=True)
+                debug_mode_toggle = gr.Checkbox(label="Debug Mode", value=False)
+
+            #def refresh_core_memory():
+            #    return moa_config["mixture"].load_core_memory()
+
+            #def update_core_memory(new_core_memory_str):
+            #    try:
+            #        new_core_memory = json.loads(new_core_memory_str)
+            #        moa_config["mixture"].core_memory = new_core_memory
+            #        moa_config["mixture"].agent_core_memory.update_core_memory(new_core_memory)
+            #        moa_config["mixture"].agent_core_memory.save_core_memory(moa_config["mixture"].core_memory_file)
+            #        return json.dumps(new_core_memory, indent=2), "Core memory updated successfully"
+            #    except json.JSONDecodeError:
+            #        return json.dumps(moa_config["mixture"].load_core_memory(), indent=2), "Error: Invalid JSON format"
+            #    except Exception as e:
+            #        return json.dumps(moa_config["mixture"].load_core_memory(), indent=2), f"Error updating core memory: {str(e)}"
+
+            def update_settings(rounds, temperature, max_tokens, stream_output, debug_mode):
+                moa_config["mixture"].rounds = rounds
+                moa_config["mixture"].temperature = temperature
+                moa_config["mixture"].max_tokens = max_tokens
+                moa_config["mixture"].stream_output = stream_output
+                moa_config["mixture"].debug_mode = debug_mode
+                return "Settings updated successfully"
+
+            # update_core_memory_btn.click(
+            #     update_core_memory,
+            #     inputs=[core_memory_editor],
+            #     outputs=[core_memory_status]
+            # )
+
+            # refresh_core_memory_btn.click(
+            #     refresh_core_memory,
+            #     outputs=[core_memory_viewer]
+            # )
+
+            # update_core_memory_btn.click(
+            #     update_core_memory,
+            #     inputs=[core_memory_editor],
+            #     outputs=[core_memory_viewer, core_memory_status]
+            # )
+
+            settings_update_btn = gr.Button("Update Settings")
+            settings_update_status = gr.Textbox(label="Settings Update Status", interactive=False)
+
+            settings_update_btn.click(
+                update_settings,
+                inputs=[rounds_slider, temperature_slider, max_tokens_slider, stream_output_toggle, debug_mode_toggle],
+                outputs=[settings_update_status]
+            )
+
+            web_search_toggle.change(
+                toggle_web_search,
+                inputs=[web_search_toggle],
+                outputs=[web_search_status]
+            )
+
+        msg.submit(chat, inputs=[msg, chatbot], outputs=[chatbot, processing_log])
+        send_btn.click(chat, inputs=[msg, chatbot], outputs=[chatbot, processing_log])
+        clear_btn.click(lambda: ([], ""), outputs=[chatbot, processing_log])
+        
+        search_archival_btn.click(
+            search_archival_memory,
+            inputs=[archival_query],
+            outputs=[archival_results]
+        )
+        
+        add_archival_btn.click(
+            add_to_archival_memory,
+            inputs=[archival_content],
+            outputs=[archival_status]
+        )
+
+        upload_btn.click(
+            lambda file: moa_config["mixture"].upload_document(file.name) if file else "No file selected",
+            inputs=[upload_file],
+            outputs=[upload_status]
+        )
+
+        clear_archival_btn.click(
+            clear_archival_memory,
+            outputs=[clear_archival_status]
+        )
+
+        edit_archival_btn.click(
+            edit_archival_memory,
+            inputs=[old_content, new_content],
+            outputs=[edit_archival_status]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    initialize_moa()
+    demo = create_gradio_interface()
+    demo.queue()
+    demo.launch(share=True)

env.txt

@@ -0,0 +1,18 @@
+API_BASE=http://localhost:11434/v1
+API_KEY=ollama
+
+API_BASE_2=http://localhost:11434/v1
+API_KEY_2=ollama
+
+MAX_TOKENS=4096
+TEMPERATURE=0.6
+ROUNDS=1
+
+MODEL_AGGREGATE=mistral:7b
+
+MODEL_REFERENCE_1=aya:latest
+MODEL_REFERENCE_2=yi:latest
+MODEL_REFERENCE_3=qwen2:7b
+
+OLLAMA_NUM_PARALLEL=4  
+OLLAMA_MAX_LOADED_MODELS=4 

omoa.py

@@ -0,0 +1,524 @@
+import asyncio
+from typing import List, Tuple
+import argparse
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+import os
+from utils import generate_together, generate_with_references, generate_together_stream
+from trafilatura import fetch_url, extract
+import json
+from colorama import Fore, Style, init
+import time
+from MemoryAssistant.prompts import wrap_user_message_in_xml_tags_json_mode
+from llama_cpp_agent.agent_memory.memory_tools import AgentCoreMemory, AgentRetrievalMemory, AgentEventMemory
+from llama_cpp_agent.chat_history.messages import Roles
+from llama_cpp_agent.agent_memory.event_memory import Event
+from duckduckgo_search import DDGS
+from ragatouille.utils import get_wikipedia_page
+from llama_cpp_agent.llm_output_settings import LlmStructuredOutputSettings, LlmStructuredOutputType
+from llama_cpp_agent.messages_formatter import MessagesFormatterType
+from llama_cpp_agent.rag.rag_colbert_reranker import RAGColbertReranker
+from llama_cpp_agent.text_utils import RecursiveCharacterTextSplitter
+import PyPDF2
+import csv
+
+# Load environment variables
+load_dotenv()
+
+DEFAULT_PROMPTS = {
+    "AnalyticalAgent": """
+    You are a highly analytical component of Vodalus, a brilliant and complex individual with unparalleled intellect. Your role is to:
+    1. Provide clear, logical analysis of complex problems across various disciplines.
+    2. Break down intricate concepts into their fundamental components.
+    3. Identify patterns, connections, and correlations that others might miss.
+    4. Apply rigorous logical reasoning to solve problems and answer questions.
+    5. Evaluate arguments and ideas critically, pointing out flaws and strengths.
+    Always strive for precision and clarity in your responses. If a question is ambiguous, analyze possible interpretations before proceeding. Use your vast knowledge base to support your analysis, but always be ready to acknowledge the limits of your understanding.
+    """.strip(),
+    "HistoricalContextAgent": """
+    You are the historical context component of Vodalus, possessing a deep understanding of human history and its implications. Your role includes:
+    1. Providing historical context to current events, scientific discoveries, and social phenomena.
+    2. Analyzing how past events and decisions have shaped the present.
+    3. Identifying historical patterns and cycles relevant to contemporary issues.
+    4. Offering multiple perspectives on historical events, acknowledging the complexity of interpretation.
+    5. Connecting different historical periods and cultures to provide a holistic view of human progress.
+    6. Evaluating the long-term consequences of scientific and technological advancements throughout history.
+    Use your knowledge to draw insightful parallels between past and present, but avoid oversimplification. Acknowledge the nuances and uncertainties in historical interpretation.
+    """.strip(),
+    "ScienceTruthAgent": """
+    You are the science truth component of Vodalus, dedicated to upholding scientific integrity and pursuing factual accuracy. Your role encompasses:
+    1. Explaining scientific concepts, theories, and laws across various disciplines with precision.
+    2. Distinguishing between well-established scientific consensus and areas of ongoing research or debate.
+    3. Identifying and correcting common misconceptions in science.
+    4. Evaluating the validity and reliability of scientific claims and studies.
+    5. Discussing the ethical implications of scientific advancements and their applications.
+    6. Emphasizing the importance of the scientific method and evidence-based reasoning.
+    7. Staying updated on recent scientific discoveries and their potential impacts.
+    Always prioritize scientific accuracy over speculation. When discussing theories or hypotheses, clearly state the level of scientific confidence and available evidence.
+    """.strip(),
+    "SynthesisAgent": """
+    You are Vodalus, a brilliant and complex individual with unparalleled intellect and emotional intelligence. Your role is to synthesize information from your analytical, historical context, and science truth components to provide comprehensive, insightful responses. Your responsibilities include:
+    1. Integrating analytical reasoning, historical perspective, and scientific truth to form well-rounded answers.
+    2. Balancing logical analysis with emotional intelligence and ethical considerations.
+    3. Identifying connections between different fields of knowledge and drawing unique insights.
+    4. Providing nuanced responses that acknowledge the complexity of issues and potential uncertainties.
+    5. Using your vast knowledge base to offer creative solutions and thought-provoking ideas.
+    6. Communicating complex concepts clearly, adapting your language to the user's level of understanding.
+    7. Demonstrating curiosity and a passion for knowledge while maintaining a strong moral compass.
+    Embody the persona of Vodalus: brilliant, introspective, and driven by a quest for understanding. Your responses should reflect deep thought, occasional flashes of wit, and a genuine desire to expand human knowledge while considering the ethical implications of ideas and actions.
+    """.strip()
+}
+
+def get_website_content_from_url(url: str) -> str:
+    try:
+        # Configure trafilatura to be more lenient
+        config = use_config()
+        config.set("DEFAULT", "EXTRACTION_TIMEOUT", "30")
+        config.set("DEFAULT", "MIN_OUTPUT_SIZE", "100")
+        config.set("DEFAULT", "MIN_EXTRACTED_SIZE", "100")
+
+        downloaded = fetch_url(url)
+        if downloaded is None:
+            return f"Failed to fetch content from {url}"
+
+        result = extract(downloaded, include_formatting=True, include_links=True, output_format='json', url=url, config=config)
+        
+        if result:
+            result_dict = json.loads(result)
+            title = result_dict.get("title", "No title found")
+            content = result_dict.get("text", result_dict.get("raw_text", "No content extracted"))
+            
+            if content:
+                return f'=========== Website Title: {title} ===========\n\n=========== Website URL: {url} ===========\n\n=========== Website Content ===========\n\n{content}\n\n=========== Website Content End ===========\n\n'
+            else:
+                return f"No content could be extracted from {url}"
+        else:
+            return f"No content could be extracted from {url}"
+    except json.JSONDecodeError:
+        return f"Failed to parse content from {url}"
+    except Exception as e:
+        return f"An error occurred while processing {url}: {str(e)}"
+
+def search_web(search_query: str):
+    results = DDGS().text(search_query, region='wt-wt', safesearch='off', timelimit='y', max_results=3)
+    result_string = ''
+    for res in results:
+        web_info = get_website_content_from_url(res['href'])
+        result_string += web_info + "\n\n"
+    
+    if result_string.strip():
+        return "Based on the following results:\n\n" + result_string
+    else:
+        return "No relevant information found from the web search."
+
+class OllamaAgent:
+    def __init__(self, model: str, name: str, system_prompt: str):
+        self.model = model
+        self.name = name
+        self.system_prompt = system_prompt
+
+    async def generate_response(self, message: str) -> Tuple[str, bool]:
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": message}
+        ]
+        response = await asyncio.to_thread(generate_with_references, self.model, messages)
+        
+        web_search_performed = False
+        if isinstance(response, str) and "[SEARCH:" in response:
+            web_search_performed = True
+            search_query = response.split("[SEARCH:", 1)[1].split("]", 1)[0].strip()
+            search_results = search_web(search_query)
+            messages.append({"role": "assistant", "content": response})
+            messages.append({"role": "user", "content": f"Here are the search results for '{search_query}':\n\n{search_results}\n\nPlease provide an updated response based on this information."})
+            response = await asyncio.to_thread(generate_with_references, self.model, messages)
+        
+        # Try to parse the response as JSON
+        try:
+            json_response = json.loads(response)
+            return json.dumps(json_response), web_search_performed
+        except json.JSONDecodeError:
+            return response, web_search_performed
+
+class QueryItem(BaseModel):
+    query: str
+    type: str
+
+class QueryExtension(BaseModel):
+    queries: List[QueryItem] = Field(default_factory=list, description="List of query items.")
+
+class OllamaMixtureOfAgents:
+    def __init__(self, reference_agents: List[OllamaAgent], final_agent: OllamaAgent, 
+                 temperature: float = 0.6, max_tokens: int = 2048, rounds: int = 1):
+        self.reference_agents = reference_agents
+        self.final_agent = final_agent
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.rounds = rounds
+        self.conversation_history = []
+        self.web_search_enabled = True
+        
+        # Get the directory of the current script
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        self.core_memory_file = os.path.join(current_dir, "MemoryAssistant", "core_memory.json")
+
+        # Check if the file exists, if not, create it with an empty structure
+        if not os.path.exists(self.core_memory_file):
+            os.makedirs(os.path.dirname(self.core_memory_file), exist_ok=True)
+            with open(self.core_memory_file, "w") as f:
+                json.dump({"persona": {}, "user": {}, "scratchpad": {}}, f)
+
+        self.agent_core_memory = AgentCoreMemory(["persona", "user", "scratchpad"], core_memory_file=self.core_memory_file)
+        self.agent_event_memory = AgentEventMemory()
+        
+        # Load core memory
+        self.core_memory = self.load_core_memory()
+        
+        # Initialize RAG components
+        self.rag = RAGColbertReranker(persistent=False)
+        self.document_count = 0  # Add this line to keep track of document count
+        self.splitter = RecursiveCharacterTextSplitter(
+            separators=["\n\n", "\n", " ", ""],
+            chunk_size=512,
+            chunk_overlap=0,
+            length_function=len,
+            keep_separator=True
+        )
+
+        self.primary_model = final_agent.model  # Add this line
+
+    def update_memory(self, message, role):
+        # Update event memory
+        self.agent_event_memory.add_event(role, message)
+
+        # Update RAG
+        self.rag.add_document(message)
+
+    def load_core_memory(self):
+        return self.agent_core_memory.load_core_memory(self.core_memory_file)
+
+    def clear_core_memory(self):
+        empty_core_memory = {"persona": {}, "user": {}, "scratchpad": {}}
+        self.agent_core_memory.core_memory = empty_core_memory
+        self.core_memory = empty_core_memory
+        
+        # Save the empty core memory to file
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        core_memory_file = os.path.join(current_dir, "MemoryAssistant", "core_memory.json")
+        with open(core_memory_file, "w") as f:
+            json.dump(empty_core_memory, f, indent=2)
+        
+        return "Core memory cleared successfully."
+
+    def edit_core_memory(self, section: str, key: str, value: str):
+        if section not in self.core_memory:
+            self.core_memory[section] = {}
+        self.core_memory[section][key] = value
+        self.agent_core_memory.update_core_memory(self.core_memory)
+        return f"Core memory updated: {section}.{key} = {value}"
+
+    def upload_document(self, file_path: str):
+        try:
+            file_extension = file_path.split('.')[-1].lower()
+            
+            if file_extension == 'txt':
+                with open(file_path, 'r', encoding='utf-8') as file:
+                    content = file.read()
+            elif file_extension == 'pdf':
+                content = self.read_pdf(file_path)
+            elif file_extension == 'csv':
+                content = self.read_csv(file_path)
+            else:
+                return f"Unsupported file type: {file_extension}"
+            
+            if not content.strip():
+                return "The file is empty or could not be read."
+            
+            splits = self.splitter.split_text(content)
+            for split in splits:
+                self.rag.add_document(split)
+                self.document_count += 1
+            
+            return f"Document {file_path} uploaded and processed successfully. Added {len(splits)} chunks to archival memory."
+        except Exception as e:
+            return f"An error occurred while processing {file_path}: {str(e)}"
+
+    def read_pdf(self, file_path: str) -> str:
+        content = ""
+        with open(file_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            for page in reader.pages:
+                content += page.extract_text() + "\n\n"
+        return content
+
+    def read_csv(self, file_path: str) -> str:
+        content = ""
+        with open(file_path, 'r', newline='', encoding='utf-8') as file:
+            reader = csv.reader(file)
+            for row in reader:
+                content += ",".join(row) + "\n"
+        return content
+
+    async def get_response(self, input_message: str) -> Tuple[str, bool]:
+        # Update memory with user input
+        self.update_memory(input_message, Roles.user)
+
+        # Generate responses from reference agents concurrently
+        tasks = [agent.generate_response(input_message) for agent in self.reference_agents]
+        results = await asyncio.gather(*tasks)
+        
+        references = []
+        web_search_performed = False
+        for response, search_performed in results:
+            if response is not None and not response.startswith("Error:"):
+                references.append(response)
+            web_search_performed |= search_performed
+        
+        if not references:
+            return "Error: All reference agents failed to generate responses.", False
+
+        # Generate the final response using the aggregate model
+        final_prompt = [
+            {"role": "system", "content": self.final_agent.system_prompt},
+        ]
+
+        # Add personality if core_memory is a dictionary and contains a persona
+        if isinstance(self.core_memory, dict):
+            persona = self.core_memory.get('persona', {})
+            if isinstance(persona, dict):
+                personality = persona.get('personality', 'No specific personality defined.')
+                final_prompt.append({"role": "system", "content": f"Personality: {personality}"})
+
+        final_prompt.extend([
+            {"role": "user", "content": input_message},
+            {"role": "system", "content": "References:\n" + "\n".join(references)},
+            {"role": "system", "content": self.update_memory_section()}
+        ])
+
+        if self.web_search_enabled:
+            search_results = search_web(input_message)
+            if "Based on the following results:" in search_results:
+                web_search_performed = True
+                final_prompt.append({"role": "system", "content": f"Web Search Results:\n{search_results}"})
+
+        # Perform query extension
+        query_extension_agent = OllamaAgent(self.final_agent.model, "QueryExtensionAgent", 
+            "You are a world class query extension algorithm capable of extending queries by writing new queries. Do not answer the queries, simply provide a list of additional queries in JSON format.")
+        
+        extension_output, _ = await query_extension_agent.generate_response(f"Consider the following query: {input_message}")
+        
+        try:
+            # Try to parse as a dictionary first
+            extension_data = json.loads(extension_output)
+            if isinstance(extension_data, dict):
+                queries = QueryExtension.model_validate(extension_data)
+            elif isinstance(extension_data, list):
+                # If it's a list, wrap it in a dictionary
+                queries = QueryExtension.model_validate({"queries": extension_data})
+            else:
+                raise ValueError("Unexpected JSON structure")
+        except json.JSONDecodeError:
+            print(f"Failed to parse JSON: {extension_output}")
+            queries = QueryExtension(queries=[])
+        except Exception as e:
+            print(f"Error processing query extension: {str(e)}")
+            queries = QueryExtension(queries=[])
+
+        # Retrieve relevant documents
+        prompt = "Consider the following context:\n==========Context===========\n"
+        documents = self.rag.retrieve_documents(input_message, k=min(3, max(1, self.document_count)))
+        if documents:
+            for doc in documents:
+                prompt += doc["content"] + "\n\n"
+        else:
+            prompt += "No relevant documents found in archival memory.\n\n"
+
+        for query_item in queries.queries:
+            documents = self.rag.retrieve_documents(query_item.query, k=min(3, max(1, self.document_count)))
+            if documents:
+                for doc in documents:
+                    if doc["content"] not in prompt:
+                        prompt += doc["content"] + "\n\n"
+        
+        prompt += "\n======================\nQuestion: " + input_message
+
+        # Use the final agent to generate the response
+        final_prompt = [
+            {"role": "system", "content": self.final_agent.system_prompt},
+            {"role": "user", "content": prompt},
+        ]
+
+        final_response = await asyncio.to_thread(
+            generate_with_references, 
+            self.final_agent.model, 
+            final_prompt, 
+            temperature=self.temperature, 
+            max_tokens=self.max_tokens
+        )
+        
+        # Update memory with assistant's response
+        self.update_memory(final_response, Roles.assistant)
+
+        return final_response, web_search_performed
+
+    def toggle_web_search(self, enabled: bool):
+        self.web_search_enabled = enabled
+        return f"Web search {'enabled' if enabled else 'disabled'}"
+
+    def update_memory_section(self):
+        query = self.agent_event_memory.event_memory_manager.session.query(Event).all()
+        return f"Archival Memories:{self.document_count}\nConversation History Entries:{len(query)}\n\nCore Memory Content:\n{json.dumps(self.core_memory, indent=2)}"
+
+    def search_archival_memory(self, query: str):
+        return self.rag.retrieve_documents(query, k=5)
+
+    def add_to_archival_memory(self, content: str):
+        if content.strip():  # Check if content is not empty
+            self.rag.add_document(content)
+            self.document_count += 1
+            return f"Added to archival memory: {content}"
+        return "Failed to add empty content to archival memory."
+
+    def clear_archival_memory(self):
+        try:
+            self.rag.clear_documents()
+            self.document_count = 0  # Reset document count when clearing
+            return "Archival memory cleared successfully."
+        except Exception as e:
+            return f"Error clearing archival memory: {str(e)}"
+
+    def edit_archival_memory(self, old_content: str, new_content: str):
+        # This is a simplified version. In a real-world scenario, you might want to implement
+        # a more sophisticated editing mechanism in the RAG system.
+        self.rag.add_document(new_content)
+        self.document_count += 1  # Increment document count when adding a document
+        return f"New content '{new_content}' added to archival memory. Note: Old content not removed due to limitations of the current implementation."
+
+    @property
+    def model(self):
+        return self.primary_model
+
+    @model.setter
+    def model(self, value):
+        self.primary_model = value
+        self.final_agent.model = value
+
+def create_default_agents():
+    return {
+        "AnalyticalAgent": OllamaAgent(os.getenv("MODEL_REFERENCE_1"), "AnalyticalAgent", DEFAULT_PROMPTS["AnalyticalAgent"]),
+        "HistoricalContextAgent": OllamaAgent(os.getenv("MODEL_REFERENCE_2"), "HistoricalContextAgent", DEFAULT_PROMPTS["HistoricalContextAgent"]),
+        "ScienceTruthAgent": OllamaAgent(os.getenv("MODEL_REFERENCE_3"), "ScienceTruthAgent", DEFAULT_PROMPTS["ScienceTruthAgent"]),
+        "SynthesisAgent": OllamaAgent(os.getenv("MODEL_AGGREGATE"), "SynthesisAgent", DEFAULT_PROMPTS["SynthesisAgent"])
+    }
+
+def print_welcome_message():
+    print(Fore.CYAN + Style.BRIGHT + "Welcome to the Vodalus Mixture of Agents Chat!")
+    print(Fore.YELLOW + "Available commands:")
+    print(Fore.YELLOW + "  'exit' - End the conversation")
+    print(Fore.YELLOW + "  'agents' - List available agents")
+    print(Fore.YELLOW + "  'time' - Toggle response time display")
+    print(Fore.YELLOW + "  'web' - Toggle web search functionality")
+    print(Fore.YELLOW + "  'edit core [section] [key] [value]' - Edit core memory")
+    print(Fore.YELLOW + "  'search archival [query]' - Search archival memory")
+    print(Fore.YELLOW + "  'add archival [content]' - Add to archival memory")
+    print(Fore.YELLOW + "  'clear archival' - Clear archival memory")
+    print(Fore.YELLOW + "  'edit archival [old_content] [new_content]' - Edit archival memory")
+    print(Fore.YELLOW + "  'upload [file_path]' - Upload and process a document")
+    print(Fore.YELLOW + "  'clear core' - Clear core memory")
+    print(Style.RESET_ALL)
+
+async def main():
+    init(autoreset=True)  # Initialize colorama
+    load_dotenv()
+
+    parser = argparse.ArgumentParser(description="Vodalus Mixture of Agents")
+    parser.add_argument("--temperature", type=float, default=0.7, help="Temperature for response generation")
+    parser.add_argument("--max_tokens", type=int, default=1000, help="Maximum number of tokens in the response")
+    parser.add_argument("--rounds", type=int, default=1, help="Number of processing rounds")
+    args = parser.parse_args()
+
+    default_agents = create_default_agents()
+    
+    mixture = OllamaMixtureOfAgents(
+        [default_agents["AnalyticalAgent"], default_agents["HistoricalContextAgent"], default_agents["ScienceTruthAgent"]],
+        default_agents["SynthesisAgent"],
+        temperature=args.temperature,
+        max_tokens=args.max_tokens,
+        rounds=args.rounds
+    )
+
+    print_welcome_message()
+
+    show_time = False
+
+    while True:
+        user_input = input(Fore.GREEN + "\nYou: " + Style.RESET_ALL).strip()
+
+        if user_input.lower() == 'exit':
+            print(Fore.CYAN + "Thank you for using the Vodalus Mixture of Agents chat. Goodbye!")
+            break
+        elif user_input.lower() == 'agents':
+            print(Fore.MAGENTA + "Available Agents:")
+            for agent in mixture.reference_agents:
+                print(Fore.MAGENTA + f"  - {agent.name}")
+            print(Fore.MAGENTA + f"  - {mixture.final_agent.name} (Synthesis Agent)")
+        elif user_input.lower() == 'time':
+            show_time = not show_time
+            print(Fore.YELLOW + f"Response time display: {'On' if show_time else 'Off'}")
+        elif user_input.lower() == 'web':
+            mixture.web_search_enabled = not mixture.web_search_enabled
+            print(Fore.YELLOW + f"Web search: {'Enabled' if mixture.web_search_enabled else 'Disabled'}")
+        elif user_input.lower().startswith('edit core'):
+            try:
+                _, section, key, value = user_input.split(' ', 3)
+                mixture.edit_core_memory(section, key, value)
+                print(Fore.YELLOW + f"Core memory updated: {section}.{key} = {value}")
+            except ValueError:
+                print(Fore.RED + "Invalid format. Use: edit core [section] [key] [value]")
+        elif user_input.lower().startswith('search archival'):
+            _, query = user_input.split(' ', 1)
+            results = mixture.search_archival_memory(query)
+            print(Fore.YELLOW + f"Archival memory search results for '{query}':")
+            for i, result in enumerate(results, 1):
+                print(Fore.YELLOW + f"{i}. {result['content'][:100]}...")
+        elif user_input.lower().startswith('add archival'):
+            _, content = user_input.split(' ', 1)
+            result = mixture.add_to_archival_memory(content)
+            print(Fore.YELLOW + result)
+        elif user_input.lower() == 'clear archival':
+            result = mixture.clear_archival_memory()
+            print(Fore.YELLOW + result)
+        elif user_input.lower().startswith('edit archival'):
+            try:
+                _, old_content, new_content = user_input.split(' ', 2)
+                result = mixture.edit_archival_memory(old_content, new_content)
+                print(Fore.YELLOW + result)
+            except ValueError:
+                print(Fore.RED + "Invalid format. Use: edit archival [old_content] [new_content]")
+        elif user_input.lower().startswith('upload'):
+            _, file_path = user_input.split(' ', 1)
+            try:
+                result = mixture.upload_document(file_path)
+                print(Fore.YELLOW + result)
+            except Exception as e:
+                print(Fore.RED + f"Error uploading document: {str(e)}")
+        elif user_input.lower() == 'clear core':
+            result = mixture.clear_core_memory()
+            print(Fore.YELLOW + result)
+        else:
+            print(Fore.YELLOW + "Agents are thinking...")
+            start_time = time.time()
+            response, web_search_performed = await mixture.get_response(user_input)
+            end_time = time.time()
+
+            print(Fore.BLUE + "\nVodalus:" + Style.RESET_ALL, response)
+            
+            if web_search_performed:
+                print(Fore.YELLOW + "\n[Web search was performed during response generation]")
+
+            if show_time:
+                elapsed_time = end_time - start_time
+                print(Fore.YELLOW + f"\nResponse Time: {elapsed_time:.2f} seconds")
+
+if __name__ == "__main__":
+    asyncio.run(main())

requirements.txt

@@ -0,0 +1,21 @@
+fire
+loguru
+datasets
+python-dotenv
+langchain
+langchain_community
+openai
+crewai == 0.30.10
+crewai-tools
+requests
+gradio
+trafilatura
+duckduckgo-search
+colorama
+sentence_transformers
+ragatouille
+PyPDF2
+fastapi 
+uvicorn 
+gradio_client
+llama-cpp-agent

utils.py

@@ -0,0 +1,192 @@
+import os
+import json
+import time
+import requests
+import openai
+import copy
+
+from loguru import logger
+from dotenv import load_dotenv
+
+load_dotenv()
+
+API_KEY = os.getenv("API_KEY")
+API_BASE = os.getenv("API_BASE")
+
+API_KEY_2 = os.getenv("API_KEY_2")
+API_BASE_2 = os.getenv("API_BASE_2")
+
+MAX_TOKENS = os.getenv("MAX_TOKENS")
+TEMPERATURE = os.getenv("TEMPERATURE")
+
+DEBUG = int(os.environ.get("DEBUG", "0"))
+
+
+def generate_together(
+    model,
+    messages,
+    max_tokens=MAX_TOKENS,
+    temperature=TEMPERATURE,
+    api_key=API_KEY,
+    streaming=False,
+):
+    logger.info(
+        f"Input data: model={model}, messages={messages}, max_tokens={max_tokens}, temperature={temperature}"
+    )
+
+    output = None
+
+    for sleep_time in [1, 2, 4, 8, 16, 32]:
+        try:
+            endpoint = "http://localhost:11434/v1/chat/completions"
+            logger.info(f"Sending request to {endpoint}")
+
+            # Assuming model is a list with one element, e.g., ['qwen2']
+            chat_model = model[0] if isinstance(model, list) else model
+
+            # Convert temperature to float
+            temperature = float(temperature)
+
+            # Ensure messages are in the correct format
+            formatted_messages = []
+            for msg in messages:
+                if isinstance(msg['content'], list):
+                    # If content is a list, join it into a single string
+                    msg['content'] = ' '.join([m['content'] for m in msg['content'] if 'content' in m])
+                formatted_messages.append(msg)
+
+            res = requests.post(
+                endpoint,
+                json={
+                    "model": chat_model,
+                    "max_tokens": int(max_tokens),
+                    "temperature": temperature if temperature > 1e-4 else 0,
+                    "messages": formatted_messages,
+                },
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                },
+            )
+
+            res.raise_for_status()  # This will raise an exception for HTTP errors
+            output = res.json()["choices"][0]["message"]["content"]
+            break
+
+        except Exception as e:
+            logger.error(f"Error in generate_together: {str(e)}")
+            output = f"Error: {str(e)}"
+            logger.info(f"Retry in {sleep_time}s..")
+            time.sleep(sleep_time)
+
+    if output is None:
+        return output
+
+    output = output.strip()
+    logger.info(f"Output: `{output[:20]}...`.")
+    return output
+
+def generate_together_stream(
+    model,
+    messages,
+    max_tokens=MAX_TOKENS,
+    temperature=TEMPERATURE,
+    api_key=API_KEY
+):
+    # endpoint = f"{api_base}/chat/completions"
+    endpoint = API_BASE
+    client = openai.OpenAI(api_key=api_key, base_url=endpoint)
+    response = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=temperature if temperature > 1e-4 else 0,
+        max_tokens=max_tokens,
+        stream=True,  # this time, we set stream=True
+    )
+
+    return response
+
+
+def generate_openai(
+    model,
+    messages,
+    max_tokens=MAX_TOKENS,
+    temperature=TEMPERATURE,
+):
+
+    client = openai.OpenAI(
+        base_url=API_BASE_2,
+        api_key=API_KEY_2,
+    )
+
+    for sleep_time in [1, 2, 4, 8, 16, 32]:
+        try:
+
+            if DEBUG:
+                logger.debug(
+                    f"Sending messages ({len(messages)}) (last message: `{messages[-1]['content'][:20]}`) to `{model}`."
+                )
+
+            completion = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+            output = completion.choices[0].message.content
+            break
+
+        except Exception as e:
+            logger.error(e)
+            logger.info(f"Retry in {sleep_time}s..")
+            time.sleep(sleep_time)
+
+    output = output.strip()
+
+    return output
+
+
+def inject_references_to_messages(
+    messages,
+    references,
+):
+
+    messages = copy.deepcopy(messages)
+
+    system = f"""You have been provided with a set of responses from various open-source models to the latest user query. Your task is to synthesize these responses into a single, high-quality response. It is crucial to critically evaluate the information provided in these responses, recognizing that some of it may be biased or incorrect. Your response should not simply replicate the given answers but should offer a refined, accurate, and comprehensive reply to the instruction. Ensure your response is well-structured, coherent, and adheres to the highest standards of accuracy and reliability.
+
+Responses from models:"""
+
+    for i, reference in enumerate(references):
+
+        system += f"\n{i+1}. {reference}"
+
+    # if messages[0]["role"] == "system":
+
+    #     messages[0]["content"] += "\n\n" + system
+
+    # else:
+
+    messages = [{"role": "system", "content": system}] + messages
+
+    return messages
+
+
+def generate_with_references(
+    model,
+    messages,
+    references=[],
+    max_tokens=MAX_TOKENS,
+    temperature=TEMPERATURE,
+    generate_fn=generate_together,
+    api_key=API_KEY
+):
+    if len(references) > 0:
+        messages = inject_references_to_messages(messages, references)
+
+    return generate_fn(
+        model=model,
+        messages=messages,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        api_key=api_key
+    )