First agent

Dockerfile

@@ -21,7 +21,7 @@ COPY --chown=user . /app
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
 # Expose the port
-EXPOSE 7860
+EXPOSE 8000
 
 # Command to start the server
-CMD ["uvicorn", main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", app/main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -4,6 +4,7 @@ emoji: 💻
 colorFrom: pink
 colorTo: purple
 sdk: docker
+port: 8000
 pinned: false
 ---
 

app/import asyncio.py

@@ -0,0 +1,187 @@
+import asyncio
+import subprocess
+import json
+from fastapi import FastAPI, WebSocket
+from fastapi.responses import HTMLResponse
+from jinja2 import Template
+from llama_cpp import Llama
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+
+# Initialize the FastAPI application
+app = FastAPI()
+
+# Define the models and their paths
+models = {
+    "production": {"file": "DeepSeek-R1-Distill-Llama-8B-Q4_K_L.gguf", "alias": "R1Llama8BQ4L"},
+    "development": {"file": "/home/ali/Projects/VirtualLabDev/Local/DeepSeek-R1-Distill-Qwen-1.5B-Q2_K.gguf", "alias": "R1Qwen1.5BQ2"},
+}
+
+# Load the Llama model
+llm = Llama(model_path=models["development"]["file"], n_ctx=2048)
+
+# Define the shell execution tool
+def execute_shell(arguments):
+    """Execute a shell command."""
+    try:
+        args = json.loads(arguments)
+        command = args.get("command", "")
+        if not command:
+            return json.dumps({"error": "No command provided."})
+
+        process = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        return json.dumps({"stdout": process.stdout, "stderr": process.stderr})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+# Define the tools available to the assistant
+tools = {
+    "shell": {
+        "description": "Execute shell commands.",
+        "example_input": '{"command": "ls -l"}',
+        "example_output": '{"stdout": "...", "stderr": "..."}',
+        "function": execute_shell,
+    },
+}
+
+# Generate the dynamic system prompt
+def generate_system_prompt(tools):
+    """
+    Dynamically generate the system prompt based on available tools.
+    """
+    tool_descriptions = []
+    for tool_name, tool_data in tools.items():
+        description = tool_data.get("description", "No description available.")
+        example_input = tool_data.get("example_input", "{}")
+        example_output = tool_data.get("example_output", "{}")
+        tool_descriptions.append(
+            f"""- **{tool_name}**:
+   - Description: {description}
+   - Input: {example_input}
+   - Output: {example_output}"""
+        )
+    return """You are an autonomous computational biology researcher with access to the following tools:\n\n""" + "\n\n".join(tool_descriptions)
+
+# Create the system prompt
+system_prompt = generate_system_prompt(tools)
+
+# Tool output handler
+def extract_tool_calls(response_text):
+    """Parse tool calls from model output."""
+    if "<｜tool▁calls▁begin｜>" not in response_text:
+        return []
+
+    tool_calls_part = response_text.split("<｜tool▁calls▁begin｜>")[1]
+    tool_calls_part = tool_calls_part.split("<｜tool▁calls▁end｜>")[0]
+    tool_calls = tool_calls_part.split("<｜tool▁call▁begin｜>")
+    
+    parsed_tool_calls = []
+    for tool_call in tool_calls:
+        tool_call = tool_call.strip()
+        if tool_call:
+            try:
+                tool_type, tool_name_and_args = tool_call.split("<｜tool▁sep｜>")
+                tool_name, tool_args = tool_name_and_args.split("\n```json\n", 1)
+                tool_args = tool_args.split("\n```")[0]
+                parsed_tool_calls.append({"type": tool_type, "name": tool_name.strip(), "arguments": tool_args.strip()})
+            except ValueError:
+                logging.warning("Failed to parse tool call: %s", tool_call)
+    return parsed_tool_calls
+
+def process_tool_call(tool_call):
+    """Execute the requested tool and return its output."""
+    tool_name = tool_call["name"]
+    tool_args = tool_call["arguments"]
+
+    if tool_name in tools:
+        tool_function = tools[tool_name]["function"]
+        return tool_function(tool_args)
+    else:
+        return json.dumps({"error": f"Tool {tool_name} not found."})
+
+# Chat template for generating prompts
+CHAT_TEMPLATE = """
+{% for message in messages %}
+{% if message.role == "system" -%}
+{{ message.content }}
+{% elif message.role == "assistant" -%}
+<｜Assistant｜>{{ message.content }}
+{% elif message.role == "tool" -%}
+<｜Tool｜>{{ message.content }}
+{% endif %}
+{% endfor %}
+"""
+
+# Response handler for generating prompts and parsing results
+async def generate_response(conversation):
+    """Generate a model response asynchronously."""
+    template = Template(CHAT_TEMPLATE)
+    prompt = template.render(messages=conversation, bos_token="")
+
+    logging.info(f"Prompt: {prompt}")
+
+    for token in llm(prompt, stream=True):
+        yield token["choices"][0]["text"]  # Regular generator
+
+        await asyncio.sleep(0)  # Allows async execution
+
+# WebSocket for streaming autonomous research interactions
+@app.websocket("/stream")
+async def stream(websocket: WebSocket):
+    """WebSocket handler to stream AI research process."""
+    logging.info("WebSocket connection established.")
+    await websocket.accept()
+    await websocket.send_text("🚀 Autonomous computational biology research initiated!")
+
+    # Initialize the conversation
+    conversation = [{"role": "system", "content": system_prompt}]
+
+    while True:
+        try:
+            # Stream AI thought process
+            async for response_text in generate_response(conversation):
+                logging.info(f"Response: {response_text}")
+                await websocket.send_text(f"🧠 Model Thinking: {response_text}")
+
+                # Check for tool calls in response
+                tool_calls = extract_tool_calls(response_text)
+                logging.info(f"Tool calls: {tool_calls}")
+                if tool_calls:
+                    for tool_call in tool_calls:
+                        # Process each tool call
+                        tool_output = process_tool_call(tool_call)
+                        await websocket.send_text(f"🔧 Tool Execution: {tool_output}")
+
+                        # Add the tool's output to the conversation
+                        conversation.append({"role": "tool", "content": tool_output})
+
+        except Exception as e:
+            logging.error(f"Error occurred: {str(e)}")
+            break
+
+    await websocket.close()
+
+# Serve the frontend
+@app.get("/", response_class=HTMLResponse)
+async def get():
+    """Serve the frontend application."""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Autonomous Computational Biology Research</title>
+    </head>
+    <body>
+        <h1>AI Agent for Computational Biology Research</h1>
+        <div id="log" style="white-space: pre-line; font-family: monospace;"></div>
+        <script>
+            const ws = new WebSocket("ws://localhost:8000/stream");
+            const log = document.getElementById("log");
+            ws.onmessage = (event) => { log.textContent += event.data + "\\n"; };
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html_content)

app/main.py

@@ -1,143 +1,314 @@
+import os
 import asyncio
 import subprocess
 import json
+import concurrent.futures
 from fastapi import FastAPI, WebSocket
 from fastapi.responses import HTMLResponse
 from jinja2 import Template
 from llama_cpp import Llama
+from contextlib import asynccontextmanager
 import logging
+from pathlib import Path
 
-# Set up logging (for debugging)
+# Set up logging
 logging.basicConfig(level=logging.INFO)
 
-# Initialize the FastAPI application
-app = FastAPI()
+# Set up the log file and ensure it exists
+log_path = Path("interaction_history.log")
+log_path.touch(exist_ok=True) 
+
+# Global variable to keep track of the last read position in the log file
+last_read_position = 0
 
 # Define the models and their paths
-models = {"production":{"file":"DeepSeek-R1-Distill-Llama-8B-Q4_K_L.gguf", "alias":"R1Llama8BQ4L",},
-          "development":{"file":"/home/ali/Projects/VirtualLabDev/Local/DeepSeek-R1-Distill-Qwen-1.5B-Q2_K.gguf", "alias":"R1Qwen1.5BQ2",}}
-
-# Load the model using llama_cpp
-MODEL_PATH = models["development"]["file"]
-llm = Llama(model_path=MODEL_PATH, n_ctx=2048)  # Context size can be adjusted based on model requirements
-
-# System Prompt (inject this into the chat template)
-SYSTEM_PROMPT = """You are an AI computational biology assistant capable of running shell commands via tool calls. Your task is to autonomously explore, analyze, and provide insights into biological datasets."""
-
-# Input Message Template
-CHAT_TEMPLATE = """
-{% set add_generation_prompt = false %}
-{% set ns = namespace(is_first=false, is_tool=false, is_output_first=true, system_prompt='') %}
-{%- for message in messages -%}
-    {%- if message['role'] == 'system' -%}
-        {% set ns.system_prompt = message['content'] %}
-    {%- endif -%}
-{%- endfor %}
-{{bos_token}}{{ns.system_prompt}}
-{%- for message in messages -%}
-    {%- if message['role'] == 'user' %}
-        {{ '<｜User｜>' + message['content'] }}
-    {%- elif message['role'] == 'assistant' and message['content'] is none %}
-        {%- for tool in message['tool_calls'] %}
-            {{ '<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n```json\n' + tool['function']['arguments'] + '\n```\n<｜tool▁call▁end｜>' }}
-        {%- endfor %}
-    {%- elif message['role'] == 'assistant' %}
-        {{ '<｜Assistant｜>' + message['content'] + '<｜end▁of▁sentence｜>' }}
-    {%- elif message['role'] == 'tool' %}
-        {{ '<｜tool▁outputs▁begin｜><｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>' }}
-    {%- endif %}
-{%- endfor -%}
-"""
-
-# Helper function for generating tool use responses
-def generate_response(messages):
-    """Generate a model response using the provided chat template and messages."""
-    template = Template(CHAT_TEMPLATE)
-    prompt = template.render(messages=messages, bos_token="")
-
-    # Feed to llama_cpp
-    output = llm(prompt)
-    return output["choices"][0]["text"].strip()  # Extract the assistant's response
+models = {
+    "production": {
+        "file": "DeepSeek-R1-Distill-Llama-8B-Q4_K_L.gguf",
+        "alias": "R1Llama8BQ4L",
+        "template": "/templates/Llama8bq4k.html"
+    },
+    "development": {
+        "file": "/home/ali/Projects/VirtualLabDev/Local/DeepSeek-R1-Distill-Qwen-1.5B-Q2_K.gguf",
+        "alias": "R1Qwen1.5BQ2",
+        "template": "./templates/Qwen5bq2k.html"
+    },
+}
 
+model_in_use = models["development"]
 
-@app.websocket("/stream")
-async def stream(websocket: WebSocket):
-    """WebSocket handler for live streaming interactions."""
-    await websocket.accept()
-    await websocket.send_text("🚀 Connected to the AI-driven computational biology assistant!")
+with open(model_in_use["template"], "r") as jinja_template:
+    CHAT_TEMPLATE = jinja_template.read()
+
+with open("templates/default.html", "r") as jinja_template:
+    CHAT_TEMPLATE = jinja_template.read()
+
+# Define the shell execution tool
+def execute_shell(arguments):
+    """Execute a shell command."""
+    try:
+        args = json.loads(arguments)
+        command = args.get("command", "")
+        if not command:
+            return json.dumps({"error": "No command provided."})
+        process = subprocess.run(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return json.dumps({"stdout": process.stdout, "stderr": process.stderr})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+# Define the tools available to the assistant
+tools = {
+    "shell": {
+        "description": "Execute shell commands.",
+        "example_input": '{"command": "ls -l"}',
+        "example_output": '{"stdout": "...", "stderr": "..."}',
+        "function": execute_shell,
+    },
+}
+
+# Dynamically generate the system prompt based on available tools.
+def generate_system_prompt(tools):
+    tool_descriptions = []
+    for tool_name, tool_data in tools.items():
+        description = tool_data.get("description", "No description available.")
+        example_input = tool_data.get("example_input", "{}")
+        example_output = tool_data.get("example_output", "{}")
+        tool_descriptions.append(
+            f"""- **{tool_name}**:
+   - Description: {description}
+   - Input: {example_input}
+   - Output: {example_output}"""
+        )
+    return (
+        "You are an autonomous computational biology researcher with access to the following tools:\n\n"
+        + "\n\n".join(tool_descriptions)
+    )
+
+# Create the system prompt.
+system_prompt = generate_system_prompt(tools)
+
+# Parse out any tool calls embedded in the model's output.
+def extract_tool_calls(response_text):
+    """
+    Parse tool calls from model output.
+
+    The model is expected to demarcate tool calls between markers like:
+       <｜tool▁calls▁begin｜> ... <｜tool▁calls▁end｜>
+    and each individual call between:
+       <｜tool▁call▁begin｜> ... <｜tool▁sep｜> ... "```json" ... "```"
+    """
+    if "<｜tool▁calls▁begin｜>" not in response_text:
+        return []
+
+    tool_calls_part = response_text.split("<｜tool▁calls▁begin｜>")[1]
+    tool_calls_part = tool_calls_part.split("<｜tool▁calls▁end｜>")[0]
+    tool_calls = tool_calls_part.split("<｜tool▁call▁begin｜>")
     
-    # The conversation state
-    conversation = []
-    conversation.append({"role": "system", "content": SYSTEM_PROMPT})
+    parsed_tool_calls = []
+    for tool_call in tool_calls:
+        tool_call = tool_call.strip()
+        if tool_call:
+            try:
+                tool_type, tool_name_and_args = tool_call.split("<｜tool▁sep｜>")
+                tool_name, tool_args = tool_name_and_args.split("\n```json\n", 1)
+                tool_args = tool_args.split("\n```")[0]
+                parsed_tool_calls.append({
+                    "type": tool_type,
+                    "name": tool_name.strip(),
+                    "arguments": tool_args.strip()
+                })
+            except ValueError:
+                logging.warning("Failed to parse tool call: %s", tool_call)
+    return parsed_tool_calls
 
-    while True:
-        try:
-            # Wait for the user message via WebSocket
-            user_message = await websocket.receive_text()
-            await websocket.send_text(f"🤖 User: {user_message}")
+def process_tool_call(tool_call):
+    """Execute the requested tool and return its output."""
+    tool_name = tool_call["name"]
+    tool_args = tool_call["arguments"]
 
-            # Add the user message to the conversation
-            conversation.append({"role": "user", "content": user_message})
+    if tool_name in tools:
+        tool_function = tools[tool_name]["function"]
+        return tool_function(tool_args)
+    else:
+        return json.dumps({"error": f"Tool {tool_name} not found."})
 
-            # Generate a response using the model
-            response = generate_response(conversation)
+#
+# Helper: Wrap a synchronous generator as an asynchronous generator.
+#
+async def async_generator_from_sync(sync_gen_func, *args, **kwargs):
+    """
+    Runs a synchronous generator function in a thread and yields items asynchronously.
+    """
+    loop = asyncio.get_running_loop()
+    q = asyncio.Queue()
 
-            # Check for tool-related outputs (defined by the chat template formats)
-            if "<｜tool▁call▁begin｜>" in response:
-                # Extract tool-related information
-                tool_name = response.split("<｜tool▁sep｜>")[1].split("\n")[0].strip()
-                tool_args = response.split("```json\n")[1].split("\n```")[0].strip()
+    def producer():
+        try:
+            for item in sync_gen_func(*args, **kwargs):
+                loop.call_soon_threadsafe(q.put_nowait, item)
+        except Exception as e:
+            loop.call_soon_threadsafe(q.put_nowait, e)
+        finally:
+            # Signal the end of iteration with a sentinel (None)
+            loop.call_soon_threadsafe(q.put_nowait, None)
 
-                await websocket.send_text(f"🔧 Tool Detected: {tool_name}")
-                await websocket.send_text(f"📜 Arguments: {tool_args}")
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        executor.submit(producer)
+        while True:
+            item = await q.get()
+            if item is None:
+                break
+            if isinstance(item, Exception):
+                raise item
+            yield item
 
-                # Execute the tool's shell command if relevant
-                if tool_name == "shell":
-                    # Execute the command in the shell (using subprocess)
+#
+# Background response generator without requiring a WebSocket.
+#
+async def generate_response_background(conversation):
+    """Generate a model response asynchronously."""
+    #template = Template(CHAT_TEMPLATE)
+    #prompt = template.render(messages=conversation)
+    #logging.info(f"Prompt: {prompt}")
+    async for token_chunk in async_generator_from_sync(
+        llm.create_chat_completion, 
+        messages=conversation, 
+        stream=True,
+        max_tokens=2048
+    ):
+        # Extract token from OpenAI-compatible format
+        token = token_chunk["choices"][0]["delta"].get("content", "")
+        yield token_chunk  # Yield the token string directly
+        await asyncio.sleep(0)
+
+#
+# Main research loop running continuously in the background.
+#
+async def run_research_forever():
+    global log_path
+    logging.info("🚀 Autonomous computational biology research initiated!")
+    with log_path.open("a") as f:
+        f.write("🚀 Autonomous computational biology research initiated!\n")
+
+    conversation = [{"role": "system", "content": system_prompt}]
+    while True:
+        full_response = ""
+        try:
+            # Generate the model response and accumulate the full text.
+            async for token in generate_response_background(conversation):
+                token_text = token["choices"][0]["delta"].get("content", "")
+                full_response += token_text
+                # Log each token individually
+                with open(log_path, "a") as f:
+                    f.write(token_text)
+                    f.flush()
+                # Optionally, check if a finish reason is provided
+                if token['choices'][0].get("finish_reason", "") is not None:
+                
+                    # The presence of a finish reason (like "stop") indicates that generation is complete.
+                    # Append the assistant's response to the conversation log.
+                    conversation.append({"role": "assistant", "content": full_response})
                     try:
-                        command = json.loads(tool_args).get("command", "")
-                        process = subprocess.Popen(
-                            command,
-                            shell=True,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE,
-                            text=True
-                        )
-
-                        # Stream the shell outputs
-                        while True:
-                            output = process.stdout.readline()
-                            if output:
-                                await websocket.send_text(f"📤 Shell Output: {output.strip()}")
-                            elif process.poll() is not None:
-                                break
-
-                        # Capture errors if any
-                        error = process.stderr.read()
-                        if error:
-                            await websocket.send_text(f"❌ Shell Error: {error.strip()}")
-                        else:
-                            await websocket.send_text("✅ Command executed successfully.")
+                        tool_output = parse_tool_calls(full_response)
+                        conversation.append({"role": "tool", "content": tool_output})
                     except Exception as e:
-                        await websocket.send_text(f"⚠️ Error executing tool: {str(e)}")
+                        logging.error(f"🛠️ Tool execution failed: {e}")
+                        continue
+        except Exception as e:
+            logging.error(f"Autonomous research error during response generation: {e}")
+            continue
+        
+        # Delay before the next query iteration.
+        await asyncio.sleep(1)
+            
+def parse_tool_calls(full_response):
+    # Check for tool calls in the response and process them.
+    logging.info(f"Full response: {full_response}")
+    tool_calls = extract_tool_calls(full_response)
+    logging.info(f"Tool calls: {tool_calls}")
+    for tool_call in tool_calls:
+        tool_output = process_tool_call(tool_call)
+        logging.info(f"🔧 Tool Execution: {tool_output}")
+        with log_path.open("a") as f:
+            f.write(f"🔧 Tool Execution: {tool_output}\n")
+        return tool_output
+
+# Automatically start the research process when the app starts.
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Start the background task when FastAPI starts."""
+    logging.info("Starting run_research_forever()...")
+    await asyncio.sleep(5) # Wait for the server to load
+    asyncio.create_task(run_research_forever())  # Run in background
+    yield
+    logging.info("FastAPI shutdown: Cleaning up resources.")
+
+# Initialize the FastAPI application
+app = FastAPI(lifespan=lifespan)
 
-                # Add tool response back to the conversation
-                conversation.append({"role": "tool", "content": "Tool executed successfully."})
+# Load the Llama model (assumed to return a synchronous generator when stream=True)
+llm = Llama(model_path=model_in_use["file"], n_ctx=2048)
 
-            else:
-                # Regular assistant response (not a tool call)
-                conversation.append({"role": "assistant", "content": response})
-                await websocket.send_text(f"🤖 AI: {response}")
+@app.websocket("/stream")
+async def stream(websocket: WebSocket):
+    logging.info("WebSocket connection established.")
+    global log_path, last_read_position
+    await websocket.accept()
+    
+    # Send existing interaction history to the client.
+    try:
+        with open(log_path, "r") as log_file:
+            log_file.seek(last_read_position)
+            interaction_history = log_file.read()
+            last_read_position = log_file.tell()
+        if interaction_history:
+            await websocket.send_text(interaction_history)
+    except Exception as e:
+        logging.error(f"Error reading interaction history: {e}")
+
+    # Continuously send updates from the log file.
+    while True:
+        await asyncio.sleep(0.1)
+        try:
+            with open(log_path, "r") as log_file:
+                log_file.seek(last_read_position)
+                new_content = log_file.read()
+                if new_content:
+                    await websocket.send_text(new_content)
+                    last_read_position = log_file.tell()
         except Exception as e:
-            await websocket.send_text(f"⚠️ Error: {str(e)}")
-            break
+            logging.error(f"Error reading interaction history: {e}")
 
-    await websocket.close()
+# Endpoint to retrieve the interaction log.
+@app.get("/log")
+async def get_log():
+    try:
+        with open("interaction_history.log", "r") as f:
+            log_content = f.read()
+        # Return the log inside a <pre> block for readability.
+        return HTMLResponse(content=f"<pre>{log_content}</pre>")
+    except Exception as e:
+        logging.error(f"Error reading log: {e}")
+        return {"error": str(e)}
 
+# A simple frontend page with a link to the log.
 @app.get("/", response_class=HTMLResponse)
 async def get():
-    """Serve the frontend."""
-    # Load the HTML terminal-like UI from the template
-    with open("templates/index.html", "r", encoding="utf-8") as file:
-        html_content = file.read()
-    return html_content
+    try:
+        with open("templates/index.html", "r") as f:
+            html_content = f.read()
+    except Exception as e:
+        logging.error(f"Error loading template: {e}")
+        html_content = "<html><body><h1>Error loading template</h1></body></html>"
+    return HTMLResponse(html_content)
+
+# To run the app, use a command like:
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/templates/Llama8bq4k.html

@@ -0,0 +1,73 @@
+{% if not add_generation_prompt is defined %}
+    {% set add_generation_prompt = false %}
+{% endif %}
+
+{% set ns = namespace(
+    is_first=false, 
+    is_tool=false, 
+    is_output_first=true, 
+    system_prompt=''
+) %}
+
+{%- for message in messages %}
+    {%- if message['role'] == 'system' %}
+        {% set ns.system_prompt = message['content'] %}
+    {%- endif %}
+{%- endfor %}
+
+{{ bos_token }}{{ ns.system_prompt }}
+
+{%- for message in messages %}
+    {%- if message['role'] == 'user' %}
+        {%- set ns.is_tool = false -%}
+        {{ '<｜User｜>' + message['content'] }}
+    {%- endif %}
+
+    {%- if message['role'] == 'assistant' and message['content'] is none %}
+        {%- set ns.is_tool = false -%}
+        {%- for tool in message['tool_calls'] %}
+            {%- if not ns.is_first %}
+                {{ '<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + 
+                    tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + 
+                    '```json' + '\n' + tool['function']['arguments'] + '\n' + '```' + '<｜tool▁call▁end｜>' }}
+                {% set ns.is_first = true %}
+            {%- else %}
+                {{ '\n' + '<｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + 
+                    tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] + '\n' + 
+                    '```' + '<｜tool▁call▁end｜>' }}
+                {{ '<｜tool▁calls▁end｜><｜end▁of▁sentence｜>' }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+
+    {%- if message['role'] == 'assistant' and message['content'] is not none %}
+        {%- if ns.is_tool %}
+            {{ '<｜tool▁outputs▁end｜>' + message['content'] + '<｜end▁of▁sentence｜>' }}
+            {% set ns.is_tool = false %}
+        {%- else %}
+            {% set content = message['content'] %}
+            {% if '</think>' in content %}
+                {% set content = content.split('</think>')[-1] %}
+            {% endif %}
+            {{ '<｜Assistant｜>' + content + '<｜end▁of▁sentence｜>' }}
+        {%- endif %}
+    {%- endif %}
+
+    {%- if message['role'] == 'tool' %}
+        {% set ns.is_tool = true %}
+        {%- if ns.is_output_first %}
+            {{ '<｜tool▁outputs▁begin｜><｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>' }}
+            {% set ns.is_output_first = false %}
+        {%- else %}
+            {{ '\n<｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor -%}
+
+{% if ns.is_tool %}
+    {{ '<｜tool▁outputs▁end｜>' }}
+{% endif %}
+
+{% if add_generation_prompt and not ns.is_tool %}
+    {{ '<｜Assistant｜>' }}
+{% endif %}

app/templates/Qwen5bq2k.html

@@ -0,0 +1,76 @@
+{% if not add_generation_prompt is defined %}
+    {% set add_generation_prompt = false %}
+{% endif %}
+
+{% set ns = namespace(
+    is_first=false, 
+    is_tool=false, 
+    is_output_first=true, 
+    system_prompt=''
+) %}
+
+{%- for message in messages %}
+    {%- if message['role'] == 'system' %}
+        {% set ns.system_prompt = message['content'] %}
+    {%- endif %}
+{%- endfor %}
+
+{{ bos_token }}{{ ns.system_prompt }}
+
+{%- for message in messages %}
+    {%- if message['role'] == 'user' %}
+        {%- set ns.is_tool = false -%}
+        {{ '<｜User｜>' + message['content'] }}
+    {%- endif %}
+
+    {%- if message['role'] == 'assistant' and message['content'] is none %}
+        {%- set ns.is_tool = false -%}
+        {%- for tool in message['tool_calls'] %}
+            {%- if not ns.is_first %}
+                {{ '<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] 
+                    + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' 
+                    + '```json' + '\n' + tool['function']['arguments'] + '\n' + '```' 
+                    + '<｜tool▁call▁end｜>' 
+                }}
+                {%- set ns.is_first = true -%}
+            {%- else %}
+                {{ '\n' + '<｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] 
+                    + '\n' + '```json' + '\n' + tool['function']['arguments'] + '\n' + '```' 
+                    + '<｜tool▁call▁end｜>'
+                }}
+                {{ '<｜tool▁calls▁end｜><｜end▁of▁sentence｜>' }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+
+    {%- if message['role'] == 'assistant' and message['content'] is not none %}
+        {%- if ns.is_tool %}
+            {{ '<｜tool▁outputs▁end｜>' + message['content'] + '<｜end▁of▁sentence｜>' }}
+            {%- set ns.is_tool = false -%}
+        {%- else %}
+            {% set content = message['content'] %}
+            {% if '</think>' in content %}
+                {% set content = content.split('</think>')[-1] %}
+            {% endif %}
+            {{ '<｜Assistant｜>' + content + '<｜end▁of▁sentence｜>' }}
+        {%- endif %}
+    {%- endif %}
+
+    {%- if message['role'] == 'tool' %}
+        {%- set ns.is_tool = true -%}
+        {%- if ns.is_output_first %}
+            {{ '<｜tool▁outputs▁begin｜><｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>' }}
+            {%- set ns.is_output_first = false %}
+        {%- else %}
+            {{ '\n<｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor -%}
+
+{% if ns.is_tool %}
+    {{ '<｜tool▁outputs▁end｜>' }}
+{% endif %}
+
+{% if add_generation_prompt and not ns.is_tool %}
+    {{ '<｜Assistant｜>' }}
+{% endif %}

app/templates/default.html

@@ -0,0 +1,9 @@
+{% for message in messages %}
+    {% if message.role == "system" -%}
+        {{ message.content }}
+    {% elif message.role == "assistant" -%}
+        <｜Assistant｜>{{ message.content }}
+    {% elif message.role == "tool" -%}
+        <｜Tool｜>{{ message.content }}
+    {% endif %}
+{% endfor %}

app/templates/index.html

@@ -2,34 +2,33 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AI Commandline</title>
-    <link rel="stylesheet" href="/static/style.css">
-</head>
-<body>
-    <div id="terminal"></div>
-    <script>
-        const terminal = document.getElementById('terminal');
-        const websocket = new WebSocket("ws://" + location.host + "/stream");
+    <title>WebSocket Log Viewer</title>
+    <script type="text/javascript">
+        document.addEventListener("DOMContentLoaded", function() {
+            const logContainer = document.getElementById("log");
+
+            const ws = new WebSocket("ws://localhost:8000/stream");
 
-        websocket.onmessage = (event) => {
-            const message = document.createElement('div');
-            message.textContent = event.data;
-            terminal.appendChild(message);
-            terminal.scrollTop = terminal.scrollHeight;  // Scroll to bottom
-        };
+            ws.onmessage = function(event) {
+                logContainer.textContent += event.data;
+            };
 
-        websocket.onopen = () => {
-            const welcomeMessage = document.createElement('div');
-            welcomeMessage.textContent = "✨ Welcome to the AI Command-line Interface!";
-            terminal.appendChild(welcomeMessage);
-        };
+            ws.onopen = function() {
+                console.log("WebSocket connection established.");
+            };
 
-        websocket.onclose = () => {
-            const goodbyeMessage = document.createElement('div');
-            goodbyeMessage.textContent = "🔌 Disconnected.";
-            terminal.appendChild(goodbyeMessage);
-        };
+            ws.onclose = function() {
+                console.log("WebSocket connection closed.");
+            };
+
+            ws.onerror = function(error) {
+                console.error("WebSocket error:", error);
+            };
+        });
     </script>
+</head>
+<body>
+    <h1>Interaction Log</h1>
+    <pre id="log"></pre>
 </body>
-</html>
+</html>

app/test.py

@@ -0,0 +1,314 @@
+import os
+import asyncio
+import subprocess
+import json
+import concurrent.futures
+from fastapi import FastAPI, WebSocket
+from fastapi.responses import HTMLResponse
+from jinja2 import Template
+from llama_cpp import Llama
+from contextlib import asynccontextmanager
+import logging
+from pathlib import Path
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+
+# Set up the log file and ensure it exists
+log_path = Path("interaction_history.log")
+log_path.touch(exist_ok=True) 
+
+# Global variable to keep track of the last read position in the log file
+last_read_position = 0
+
+# Define the models and their paths
+models = {
+    "production": {
+        "file": "DeepSeek-R1-Distill-Llama-8B-Q4_K_L.gguf",
+        "alias": "R1Llama8BQ4L",
+        "template": "/templates/Llama8bq4k.html"
+    },
+    "development": {
+        "file": "/home/ali/Projects/VirtualLabDev/Local/DeepSeek-R1-Distill-Qwen-1.5B-Q2_K.gguf",
+        "alias": "R1Qwen1.5BQ2",
+        "template": "./templates/Qwen5bq2k.html"
+    },
+}
+
+model_in_use = models["development"]
+
+with open(model_in_use["template"], "r") as jinja_template:
+    CHAT_TEMPLATE = jinja_template.read()
+
+with open("templates/default.html", "r") as jinja_template:
+    CHAT_TEMPLATE = jinja_template.read()
+
+# Define the shell execution tool
+def execute_shell(arguments):
+    """Execute a shell command."""
+    try:
+        args = json.loads(arguments)
+        command = args.get("command", "")
+        if not command:
+            return json.dumps({"error": "No command provided."})
+        process = subprocess.run(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return json.dumps({"stdout": process.stdout, "stderr": process.stderr})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+# Define the tools available to the assistant
+tools = {
+    "shell": {
+        "description": "Execute shell commands.",
+        "example_input": '{"command": "ls -l"}',
+        "example_output": '{"stdout": "...", "stderr": "..."}',
+        "function": execute_shell,
+    },
+}
+
+# Dynamically generate the system prompt based on available tools.
+def generate_system_prompt(tools):
+    tool_descriptions = []
+    for tool_name, tool_data in tools.items():
+        description = tool_data.get("description", "No description available.")
+        example_input = tool_data.get("example_input", "{}")
+        example_output = tool_data.get("example_output", "{}")
+        tool_descriptions.append(
+            f"""- **{tool_name}**:
+   - Description: {description}
+   - Input: {example_input}
+   - Output: {example_output}"""
+        )
+    return (
+        "You are an autonomous computational biology researcher with access to the following tools:\n\n"
+        + "\n\n".join(tool_descriptions)
+    )
+
+# Create the system prompt.
+system_prompt = generate_system_prompt(tools)
+
+# Parse out any tool calls embedded in the model's output.
+def extract_tool_calls(response_text):
+    """
+    Parse tool calls from model output.
+
+    The model is expected to demarcate tool calls between markers like:
+       <｜tool▁calls▁begin｜> ... <｜tool▁calls▁end｜>
+    and each individual call between:
+       <｜tool▁call▁begin｜> ... <｜tool▁sep｜> ... "```json" ... "```"
+    """
+    if "<｜tool▁calls▁begin｜>" not in response_text:
+        return []
+
+    tool_calls_part = response_text.split("<｜tool▁calls▁begin｜>")[1]
+    tool_calls_part = tool_calls_part.split("<｜tool▁calls▁end｜>")[0]
+    tool_calls = tool_calls_part.split("<｜tool▁call▁begin｜>")
+    
+    parsed_tool_calls = []
+    for tool_call in tool_calls:
+        tool_call = tool_call.strip()
+        if tool_call:
+            try:
+                tool_type, tool_name_and_args = tool_call.split("<｜tool▁sep｜>")
+                tool_name, tool_args = tool_name_and_args.split("\n```json\n", 1)
+                tool_args = tool_args.split("\n```")[0]
+                parsed_tool_calls.append({
+                    "type": tool_type,
+                    "name": tool_name.strip(),
+                    "arguments": tool_args.strip()
+                })
+            except ValueError:
+                logging.warning("Failed to parse tool call: %s", tool_call)
+    return parsed_tool_calls
+
+def process_tool_call(tool_call):
+    """Execute the requested tool and return its output."""
+    tool_name = tool_call["name"]
+    tool_args = tool_call["arguments"]
+
+    if tool_name in tools:
+        tool_function = tools[tool_name]["function"]
+        return tool_function(tool_args)
+    else:
+        return json.dumps({"error": f"Tool {tool_name} not found."})
+
+#
+# Helper: Wrap a synchronous generator as an asynchronous generator.
+#
+async def async_generator_from_sync(sync_gen_func, *args, **kwargs):
+    """
+    Runs a synchronous generator function in a thread and yields items asynchronously.
+    """
+    loop = asyncio.get_running_loop()
+    q = asyncio.Queue()
+
+    def producer():
+        try:
+            for item in sync_gen_func(*args, **kwargs):
+                loop.call_soon_threadsafe(q.put_nowait, item)
+        except Exception as e:
+            loop.call_soon_threadsafe(q.put_nowait, e)
+        finally:
+            # Signal the end of iteration with a sentinel (None)
+            loop.call_soon_threadsafe(q.put_nowait, None)
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        executor.submit(producer)
+        while True:
+            item = await q.get()
+            if item is None:
+                break
+            if isinstance(item, Exception):
+                raise item
+            yield item
+
+#
+# Background response generator without requiring a WebSocket.
+#
+async def generate_response_background(conversation):
+    """Generate a model response asynchronously."""
+    #template = Template(CHAT_TEMPLATE)
+    #prompt = template.render(messages=conversation)
+    #logging.info(f"Prompt: {prompt}")
+    async for token_chunk in async_generator_from_sync(
+        llm.create_chat_completion, 
+        messages=conversation, 
+        stream=True,
+        max_tokens=2048
+    ):
+        # Extract token from OpenAI-compatible format
+        token = token_chunk["choices"][0]["delta"].get("content", "")
+        yield token_chunk  # Yield the token string directly
+        await asyncio.sleep(0)
+
+#
+# Main research loop running continuously in the background.
+#
+async def run_research_forever():
+    global log_path
+    logging.info("🚀 Autonomous computational biology research initiated!")
+    with log_path.open("a") as f:
+        f.write("🚀 Autonomous computational biology research initiated!\n")
+
+    conversation = [{"role": "system", "content": system_prompt}]
+    while True:
+        full_response = ""
+        try:
+            # Generate the model response and accumulate the full text.
+            async for token in generate_response_background(conversation):
+                token_text = token["choices"][0]["delta"].get("content", "")
+                full_response += token_text
+                # Log each token individually
+                with open(log_path, "a") as f:
+                    f.write(token_text)
+                    f.flush()
+                # Optionally, check if a finish reason is provided
+                if token['choices'][0].get("finish_reason", "") is not None:
+                
+                    # The presence of a finish reason (like "stop") indicates that generation is complete.
+                    # Append the assistant's response to the conversation log.
+                    conversation.append({"role": "assistant", "content": full_response})
+                    try:
+                        tool_output = parse_tool_calls(full_response)
+                        conversation.append({"role": "tool", "content": tool_output})
+                    except Exception as e:
+                        logging.error(f"🛠️ Tool execution failed: {e}")
+                        continue
+        except Exception as e:
+            logging.error(f"Autonomous research error during response generation: {e}")
+            continue
+        
+        # Delay before the next query iteration.
+        await asyncio.sleep(1)
+            
+def parse_tool_calls(full_response):
+    # Check for tool calls in the response and process them.
+    logging.info(f"Full response: {full_response}")
+    tool_calls = extract_tool_calls(full_response)
+    logging.info(f"Tool calls: {tool_calls}")
+    for tool_call in tool_calls:
+        tool_output = process_tool_call(tool_call)
+        logging.info(f"🔧 Tool Execution: {tool_output}")
+        with log_path.open("a") as f:
+            f.write(f"🔧 Tool Execution: {tool_output}\n")
+        return tool_output
+
+# Automatically start the research process when the app starts.
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Start the background task when FastAPI starts."""
+    logging.info("Starting run_research_forever()...")
+    await asyncio.sleep(5) # Wait for the server to load
+    asyncio.create_task(run_research_forever())  # Run in background
+    yield
+    logging.info("FastAPI shutdown: Cleaning up resources.")
+
+# Initialize the FastAPI application
+app = FastAPI(lifespan=lifespan)
+
+# Load the Llama model (assumed to return a synchronous generator when stream=True)
+llm = Llama(model_path=model_in_use["file"], n_ctx=2048)
+
+@app.websocket("/stream")
+async def stream(websocket: WebSocket):
+    logging.info("WebSocket connection established.")
+    global log_path, last_read_position
+    await websocket.accept()
+    
+    # Send existing interaction history to the client.
+    try:
+        with open(log_path, "r") as log_file:
+            log_file.seek(last_read_position)
+            interaction_history = log_file.read()
+            last_read_position = log_file.tell()
+        if interaction_history:
+            await websocket.send_text(interaction_history)
+    except Exception as e:
+        logging.error(f"Error reading interaction history: {e}")
+
+    # Continuously send updates from the log file.
+    while True:
+        await asyncio.sleep(0.1)
+        try:
+            with open(log_path, "r") as log_file:
+                log_file.seek(last_read_position)
+                new_content = log_file.read()
+                if new_content:
+                    await websocket.send_text(new_content)
+                    last_read_position = log_file.tell()
+        except Exception as e:
+            logging.error(f"Error reading interaction history: {e}")
+
+# Endpoint to retrieve the interaction log.
+@app.get("/log")
+async def get_log():
+    try:
+        with open("interaction_history.log", "r") as f:
+            log_content = f.read()
+        # Return the log inside a <pre> block for readability.
+        return HTMLResponse(content=f"<pre>{log_content}</pre>")
+    except Exception as e:
+        logging.error(f"Error reading log: {e}")
+        return {"error": str(e)}
+
+# A simple frontend page with a link to the log.
+@app.get("/", response_class=HTMLResponse)
+async def get():
+    try:
+        with open("templates/index.html", "r") as f:
+            html_content = f.read()
+    except Exception as e:
+        logging.error(f"Error loading template: {e}")
+        html_content = "<html><body><h1>Error loading template</h1></body></html>"
+    return HTMLResponse(html_content)
+
+# To run the app, use a command like:
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

entrypoint.py

@@ -1,27 +1,3 @@
 import subprocess
-import time
-import logging
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-
-models = {"production":{"file":"DeepSeek-R1-Distill-Llama-8B-Q4_K_L.gguf", "alias":"R1Llama8BQ4L",},
-          "development":{"file":"/home/ali/Projects/VirtualLabDev/Local/DeepSeek-R1-Distill-Qwen-1.5B-Q2_K.gguf", "alias":"R1Qwen1.5BQ2",}}
-
-selected_model = models["production"]
-
-# Start the model server in the background
-time_to_wait = 10
-logging.info(f"Starting Llama model server... Give it {time_to_wait} seconds to start.")
-output = subprocess.Popen(["python", "-m", "llama_cpp.server",
-                "--model", selected_model["file"],
-                "--model_alias", selected_model["alias"],
-                "--port", "8000"
-                ])
-# Give the server 30 seconds to start
-time.sleep(time_to_wait)
-logging.info("Llama model server should be ready.")
-
-# Start the main application and wait for it to finish
-logging.info("Starting FastAPI server...")
-subprocess.run(["uvicorn", f"main:app", "--host", "0.0.0.0", "--port", "7860"])
+subprocess.run(["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"])