Merge pull request #6 from gperdrizet/dev

client/gradio_functions.py

@@ -3,17 +3,75 @@
 import os
 import re
 
-def update_log(n: int = 10):
-    '''Gets updated logging output from disk to display to user.
+import logging
+from pathlib import Path
+from logging.handlers import RotatingFileHandler
+
+
+def configure_root_logger() -> None:
+    '''Configures root logger for project wide logging.'''
+
+    # Make sure log directory exists
+    Path('logs').mkdir(parents=True, exist_ok=True)
+
+    # Clear old logs if present
+    delete_old_logs('logs', 'rss_client')
+
+    # Set up the root logger so we catch logs from
+    logging.basicConfig(
+        handlers=[RotatingFileHandler(
+            'logs/rss_client.log',
+            maxBytes=100000,
+            backupCount=10,
+            mode='w'
+        )],
+        level=logging.INFO,
+        format='%(levelname)s - %(name)s - %(message)s'
+    )
+
+
+def get_dialog_logger(name: str = 'dialog', clear: bool = True) -> logging.Logger:
+    '''Sets up logger for model's internal dialog.'''
+
+    # Make sure log directory exists
+    Path('logs').mkdir(parents=True, exist_ok=True)
+
+    # Clear old logs if desired
+    if clear:
+        delete_old_logs('logs', 'dialog')
+
+    # Create logger
+    new_dialog_logger = logging.getLogger(name)
+
+    # Create handler
+    handler = RotatingFileHandler(
+        'logs/dialog.log',
+        maxBytes=100000,
+        backupCount=10,
+        mode='w'
+    )
+
+    # Add format to handler
+    formatter = logging.Formatter('%(message)s')
+    handler.setFormatter(formatter)
+    new_dialog_logger.addHandler(handler)
+
+    # Set logging level
+    new_dialog_logger.setLevel(logging.INFO)
+
+    return new_dialog_logger
+
+def update_dialog(n: int = 10):
+    '''Gets updated internal dialog logging output from disk to display to user.
     
     Args:
-        n: number of most recent lines of logging output to display
+        n: number of most recent lines of internal dialog output to display
 
     Returns:
-        Logging output as string
+        Internal dialog logging output as string
     '''
 
-    with open('logs/rss_client.log', 'r', encoding='utf-8') as log_file:
+    with open('logs/dialog.log', 'r', encoding='utf-8') as log_file:
         lines = log_file.readlines()
 
     return ''.join(lines[-n:])

client/interface.py

@@ -2,23 +2,36 @@
 
 import json
 import logging
+import queue
 from anthropic.types import text_block
 from gradio.components.chatbot import ChatMessage
 
 from client import prompts
 from client.anthropic_bridge import AnthropicBridge
+import client.gradio_functions as gradio_funcs
+
+# Create dialog logger
+dialog = gradio_funcs.get_dialog_logger(clear = True)
+
 
 async def agent_input(
         bridge: AnthropicBridge,
+        output_queue: queue.Queue,
         chat_history: list
 ) -> list:
 
     '''Handles model interactions.'''
 
-    function_logger = logging.getLogger(__name__ + '.agent_input')
+    logger = logging.getLogger(__name__ + '.agent_input')
+
+    user_query = chat_history[-1]['content']
+    dialog.info('User: %s', user_query)
 
     input_messages = format_chat_history(chat_history)
-    result = await bridge.process_query(prompts.DEFAULT_SYSTEM_PROMPT, input_messages)
+    result = await bridge.process_query(
+        prompts.DEFAULT_SYSTEM_PROMPT,
+        input_messages
+    )
 
     if result['tool_result']:
         tool_call = result['tool_call']
@@ -28,7 +41,6 @@ async def agent_input(
 
             tool_parameters = tool_call['parameters']
             website = tool_parameters['website']
-            user_query = input_messages[-1]['content']
             response_content = result['llm_response'].content[0]
 
             if isinstance(response_content, text_block.TextBlock):
@@ -36,9 +48,9 @@ async def agent_input(
             else:
                 intermediate_reply = f'I Will check the {website} RSS feed for you'
 
-            function_logger.info('User query: %s', user_query)
-            function_logger.info('Model intermediate reply: %s', intermediate_reply)
-            function_logger.info('LLM called %s on %s', tool_name, website)
+            output_queue.put(intermediate_reply)
+            dialog.info('LLM: %s', intermediate_reply)
+            dialog.info('LLM: called %s on %s', tool_name, website)
 
             articles = json.loads(result['tool_result'].content)['text']
 
@@ -54,27 +66,23 @@ async def agent_input(
                 'content': prompt
             }]
 
-            function_logger.info('Re-prompting input %s', input_message)
-            result = await bridge.process_query(prompts.GET_FEED_SYSTEM_PROMPT, input_message)
+            dialog.info('System: re-prompting LLM with return from %s call', tool_name)
+            dialog.info('New prompt: %s ...', prompt[:150])
+
+            logger.info('Re-prompting input %s', input_message)
+            result = await bridge.process_query(
+                prompts.GET_FEED_SYSTEM_PROMPT,
+                input_message
+            )
 
             try:
 
-                final_reply = result['llm_response'].content[0].text
+                reply = result['llm_response'].content[0].text
 
             except (IndexError, AttributeError):
-                final_reply = 'No final reply from model'
-
-            function_logger.info('LLM final reply: %s', final_reply)
+                reply = 'No final reply from model'
 
-            chat_history.append({
-                "role": "assistant",
-                "content": intermediate_reply
-            })
-
-            chat_history.append({
-                "role": "assistant",
-                "content": final_reply
-            })
+            logger.info('LLM final reply: %s', reply)
 
     else:
         try:
@@ -83,14 +91,11 @@ async def agent_input(
         except AttributeError:
             reply = 'Bad reply - could not parse'
 
-        function_logger.info('Direct, no-tool reply: %s', reply)
-
-        chat_history.append({
-            "role": "assistant",
-            "content": reply
-        })
+        logger.info('Direct, no-tool reply: %s', reply)
 
-    return chat_history
+    dialog.info('LLM: %s ...', reply[:100])
+    output_queue.put(reply)
+    output_queue.put('bot-finished')
 
 
 def format_chat_history(history) -> list[dict]:
@@ -102,9 +107,9 @@ def format_chat_history(history) -> list[dict]:
         if isinstance(chat_message, ChatMessage):
             role, content = chat_message.role, chat_message.content
         else:
-            role, content = chat_message.get("role"), chat_message.get("content")
+            role, content = chat_message.get('role'), chat_message.get('content')
 
-        if role in ["user", "assistant", "system"]:
-            messages.append({"role": role, "content": content})
+        if role in ['user', 'assistant', 'system']:
+            messages.append({'role': role, 'content': content})
 
     return messages

client/prompts.py

@@ -5,19 +5,10 @@ from string import Template
 
 DEFAULT_SYSTEM_PROMPT = 'You are a helpful tool-using assistant.'
 
-GET_FEED_SYSTEM_PROMPT = '''
-You are a helpful assistant. Your job is to facilitate interactions between
-Human users and LLM agents.
-'''
+GET_FEED_SYSTEM_PROMPT = '''You are a helpful assistant. Your job is to facilitate interactions between Human users and LLM agents.'''
 
 GET_FEED_PROMPT = Template(
-'''
-Below is an exchange between a user and an agent. The user has asked 
-the agent to get new content from the $website RSS feed. In order to
-complete the request, the agent has called a function which returned
-the RSS feed content from $website in JSON format. Your job is to 
-complete the exchange by using the returned JSON RSS feed data to write
-a human readable reply to the user.
+'''Below is an exchange between a user and an agent. The user has asked the agent to get new content from the $website RSS feed. In order to complete the request, the agent has called a function which returned the RSS feed content from $website in JSON format. Your job is to complete the exchange by using the returned JSON RSS feed data to write a human readable reply to the user.
 
 user: $user_query
 
@@ -27,6 +18,5 @@ function call: get_feed_content($website)
 
 function return: $articles
 
-assistant:
-'''                       
-)
+assistant:'''
+)

rss_client.py

@@ -1,10 +1,13 @@
 '''RSS MCP server demonstration client app.'''
 
 import os
+import asyncio
 import logging
+import time
+import queue
+from typing import Tuple
 from pathlib import Path
 from logging.handlers import RotatingFileHandler
-
 import gradio as gr
 import assets.html as html
 import client.gradio_functions as gradio_funcs
@@ -12,15 +15,15 @@ import client.interface as interface
 from client.mcp_client import MCPClientWrapper
 from client.anthropic_bridge import AnthropicBridge
 
+# Set-up root logger so we send logs from the MCP client,
+# Gradio and the rest of the project to the same file.
 # Make sure log directory exists
 Path('logs').mkdir(parents=True, exist_ok=True)
 
 # Clear old logs if present
 gradio_funcs.delete_old_logs('logs', 'rss_client')
 
-# Set-up logger
-logger = logging.getLogger()
-
+# Configure
 logging.basicConfig(
     handlers=[RotatingFileHandler(
         'logs/rss_client.log',
@@ -32,12 +35,14 @@ logging.basicConfig(
     format='%(levelname)s - %(name)s - %(message)s'
 )
 
+# Get a logger
 logger = logging.getLogger(__name__)
 
 # Handle MCP server connection and interactions
 RSS_CLIENT = MCPClientWrapper(
     'https://agents-mcp-hackathon-rss-mcp-server.hf.space/gradio_api/mcp/sse'
 )
+logger.info('Started MCP client')
 
 # Handles Anthropic API I/O
 BRIDGE = AnthropicBridge(
@@ -45,25 +50,53 @@ BRIDGE = AnthropicBridge(
     api_key=os.environ['ANTHROPIC_API_KEY']
 )
 
-async def send_message(message: str, chat_history: list) -> str:
-    '''Submits user message to agent.
-    
+logger.info('Started Anthropic API bridge')
+
+# Queue to return responses to user
+OUTPUT_QUEUE = queue.Queue()
+logger.info('Created response queue')
+
+def user_message(message: str, history: list) -> Tuple[str, list]:
+    '''Adds user message to conversation and returns for immediate posting.
+
     Args:
         message: the new message from the user as a string
         chat_history: list containing conversation history where each element is
             a dictionary with keys 'role' and 'content'
 
+    Returns
+        New chat history with user's message added.
+    '''
+
+    return '', history + [{'role': 'user', 'content': message}]
+
+
+def send_message(chat_history: list):
+    '''Submits chat history to agent, streams reply, one character at a time.
+    
+    Args:
+        chat_history: list containing conversation history where each element is
+            a dictionary with keys 'role' and 'content'
+
     Returns
         New chat history with model's response to user added.
     '''
 
-    function_logger = logging.getLogger(__name__ + '.submit_input')
-    function_logger.info('Submitting user message: %s', message)
+    asyncio.run(interface.agent_input(BRIDGE, OUTPUT_QUEUE, chat_history))
 
-    chat_history.append({"role": "user", "content": message})
-    chat_history = await interface.agent_input(BRIDGE, chat_history)
+    while True:
+        response = OUTPUT_QUEUE.get()
 
-    return '', chat_history
+        if response == 'bot-finished':
+            break
+
+        chat_history.append({'role': 'assistant', 'content': ''})
+
+        for character in response:
+            chat_history[-1]['content'] += character
+            time.sleep(0.005)
+
+            yield chat_history
 
 
 with gr.Blocks(title='MCP RSS client') as demo:
@@ -75,15 +108,18 @@ with gr.Blocks(title='MCP RSS client') as demo:
     # MCP connection/tool dump
     connect_btn = gr.Button('Connect to MCP server')
     status = gr.Textbox(label='MCP server tool dump', interactive=False, lines=4)
-    connect_btn.click(RSS_CLIENT.list_tools, outputs=status) # pylint: disable=no-member
+    connect_btn.click(# pylint: disable=no-member
+        RSS_CLIENT.list_tools,
+        outputs=status
+    )
 
-    # Log output
-    logs = gr.Textbox(label='Client logs', lines=10, max_lines=10)
-    timer = gr.Timer(1, active=True)
+    # Dialog log output
+    dialog_output = gr.Textbox(label='Internal dialog', lines=10, max_lines=100)
+    timer = gr.Timer(0.5, active=True)
 
     timer.tick( # pylint: disable=no-member
-        lambda: gradio_funcs.update_log(), # pylint: disable=unnecessary-lambda
-        outputs=logs
+        lambda: gradio_funcs.update_dialog(), # pylint: disable=unnecessary-lambda
+        outputs=dialog_output
     )
 
     # Chat interface
@@ -102,17 +138,20 @@ with gr.Blocks(title='MCP RSS client') as demo:
     )
 
     msg.submit( # pylint: disable=no-member
-        send_message,
-        [msg, chatbot],
-        [msg, chatbot]
+        user_message, [msg, chatbot], [msg, chatbot], queue=False
+    ).then(
+        send_message, chatbot, chatbot
     )
 
+
 if __name__ == '__main__':
 
     current_directory = os.getcwd()
 
     if 'pyrite' in current_directory:
+        logger.info('Starting RASS on LAN')
         demo.launch(server_name='0.0.0.0', server_port=7860)
 
     else:
+        logger.info('Starting RASS')
         demo.launch()