Merge pull request #12 from gperdrizet/dev

assets/html.py

@@ -3,18 +3,58 @@
 TITLE = (
     '''
         <center> 
-            <h1>Agentic RSS reader</h1>
+            <h1>RASS (retrieval augmented simple syndication) Agent</h1>
+            <h2>Agentic RSS feed reader</h2>
         </center>
     '''
 )
 
 DESCRIPTION = (
     '''
-        <p>Uses sister Space 
+        <p><b>Problem</b>: I love RSS feeds, but need help keeping up with all of the content from my subscriptions.
+        
+        <b>Solution</b>: Build a tool to allow LLMs to find and interact with RSS feeds on behalf of the user.</p>
+        <h2>Introduction</h2>
+        <p>This demonstration uses sister space
         <a href='https://huggingface.co/spaces/Agents-MCP-Hackathon/rss-mcp-server'>
-        RSS feed reader</a> via MCP. Click 'Connect to MCP server' to get started. 
-        Check out the <a href='https://github.com/gperdrizet/MCP-hackathon/tree/main'>
+        RSS feed reader</a> via MCP to interact with RSS feeds. Click 'Connect to MCP 
+        server' to get started. If it takes a minute or two to reply, don't worry the inference
+        container was probably cold and spinning up. Check out the 
+        <a href='https://github.com/gperdrizet/MCP-hackathon/tree/main'>
         main project repo on GitHub</a>. Both Spaces by
         <a href=https://www.linkedin.com/in/gperdrizet/'>George Perdrizet</a>.</p>
+
+        I love RSS feeds - they remind me of a time when the internet was a weird and
+        wonderful place, filled with interesting content hiding behind every link. The tools
+        to produce and navigate that content have improved by leaps and bounds. However, 
+        the improvement has not come without some losses. Content often feels homogeneous and
+        it is too often painfully apparent that your favorite platform has a large degree of
+        control over what content you see and what content you don't.
+
+        This tool give the user back some of that control. It let's them decide what content
+        and sources they are interested in. I built it because I want access to diverse,
+        unfiltered publishing by many sources, paired modern AI to help me navigate it. 
+        I want the model to help me ingest my feed, not create it for me!
     '''
 )
+
+FEATURES_TOOLS ='''
+    ## Features
+
+    1. Inference with Anthropic's efficient claude-3-haiku model.
+    2. Custom MCP client with asynchronous server side events, retry and error handling based on the excellent repo by [Adel Zaalouk](https://github.com/zanetworker/mcp-playground/tree/main).
+    3. Multi-turn re-prompting to allow LLM workflows with multiple tool calls.
+    4. Queue and worker system to show user what's going on 'under the hood' while the model calls tools and generates replies. 
+    
+    ## Tools
+
+    1. `get_feed()`: Given a website name or URL, find its RSS feed and
+        return recent article titles, links and a generated summary of content if
+        avalible. Caches results for fast retrieval by other tools. Embeds content
+        to vector database for subsequent RAG.
+    2. `context_search()`: Vector search on article content for RAG context.
+    3. `find_article()`: Uses vector search on article content to find title of article
+        that user is referring to.
+    4. `get_summary()`: Gets article summary from Redis cache using article title.
+    5. `get_link()`: Gets article link from Redis cache using article title.
+'''

client/interface.py

@@ -1,14 +1,13 @@
 '''Functions for controlling chat flow between Gradio and Anthropic/MCP'''
 
-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
+import client.tool_workflows as tool_funcs
 
 # Create dialog logger
 dialog = gradio_funcs.get_dialog_logger(clear = True)
@@ -26,6 +25,13 @@ async def agent_input(
     reply = 'No reply from LLM'
 
     user_query = chat_history[-1]['content']
+
+    if len(chat_history) > 1:
+        prior_reply = chat_history[-2]['content']
+
+    else:
+        prior_reply = ''
+
     dialog.info('User: %s', user_query)
 
     input_messages = format_chat_history(chat_history)
@@ -34,70 +40,29 @@ async def agent_input(
         input_messages
     )
 
-    logger.debug(result)
-
     if result['tool_result']:
-        tool_call = result['tool_call']
-        tool_name = tool_call['name']
-
-        if tool_name == 'rss_mcp_server_get_feed':
-
-            tool_parameters = tool_call['parameters']
-            website = tool_parameters['website']
-            response_content = result['llm_response'].content[0]
-
-            if isinstance(response_content, text_block.TextBlock):
-                intermediate_reply = response_content.text
-            else:
-                intermediate_reply = f'I Will check the {website} RSS feed for you'
-
-            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']
-
-            prompt = prompts.GET_FEED_PROMPT.substitute(
-                website=website,
-                user_query=user_query,
-                intermediate_reply=intermediate_reply,
-                articles=articles
-            )
-
-            input_message =[{
-                'role': 'user',
-                'content': prompt
-            }]
-
-            dialog.info('System: re-prompting LLM with return from %s call', tool_name)
-            dialog.info('New prompt: %s ...', prompt[:75])
-
-            logger.info('Re-prompting input %s', input_message)
-            result = await bridge.process_query(
-                prompts.GET_FEED_SYSTEM_PROMPT,
-                input_message
-            )
-
-            try:
-
-                reply = result['llm_response'].content[0].text
-
-            except (IndexError, AttributeError):
-                reply = 'No final reply from model'
-
-            logger.info('LLM final reply: %s', reply)
+        logger.info('LLM called tool, entering tool loop.')
+        await tool_funcs.tool_loop(
+            user_query,
+            prior_reply,
+            result,
+            bridge,
+            output_queue,
+            dialog
+        )
 
     else:
+        logger.info('LLM replied directly.')
+
         try:
             reply = result['llm_response'].content[0].text
 
         except AttributeError:
             reply = 'Bad reply - could not parse'
 
-        logger.info('Direct, no-tool reply: %s', reply)
+        logger.info('Reply: %s', reply)
+        output_queue.put(reply)
 
-    dialog.info('LLM: %s ...', reply[:75])
-    output_queue.put(reply)
     output_queue.put('bot-finished')
 
 

client/mcp_client.py

@@ -71,7 +71,7 @@ class MCPTimeoutError(Exception):
 class MCPClientWrapper:
     '''Main client wrapper class for interacting with Model Context Protocol (MCP) endpoints'''
 
-    def __init__(self, endpoint: str, timeout: float = 30.0, max_retries: int = 3):
+    def __init__(self, endpoint: str, timeout: float = 360.0, max_retries: int = 3):
         '''Initialize MCP client with endpoint URL
         
         Args:

client/prompts.py

@@ -5,18 +5,88 @@ 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.'''
+REPROMPTING_SYSTEM_PROMPT = '''
+You are a helpful assistant. Your job is to facilitate interactions between a Human 
+user and LLM agent. To complete the user's request or answer their question, you may
+need to call multiple functions sequentially and use each output to formulate the next
+function call until you arrive at the final answer. But if you can satisfy the request
+with a single function call, you should do so.
+
+Here is an example exchange between the user and agent using multiple functions calls:
+
+user: Can you give me a link to the article about the FAA modernizing air traffic control technology?
+
+agent: OK, let me find the article you are referring to.
+
+function call: find_article("FAA modernizing air traffic control technology")
+
+function return: {"title": "FAA To Eliminate Floppy Disks Used In Air Traffic Control Systems"}
+
+function call: get_link("FAA To Eliminate Floppy Disks Used In Air Traffic Control Systems")
+
+function return: {"link": "https://www.tomshardware.com/the-faa-seeks-to-eliminate-floppy-disk-usage-in-air-traffic-control-systems"}
+
+assistant: Here is the link to the article: [FAA To Eliminate Floppy Disks Used In Air Traffic Control Systems](https://www.tomshardware.com/the-faa-seeks-to-eliminate-floppy-disk-usage-in-air-traffic-control-systems)
+'''
 
 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
 
 agent: $intermediate_reply
 
-function call: get_feed_content($website)
+function call: get_feed_content("$website")
 
 function return: $articles
 
 assistant:'''
 )
+
+OTHER_TOOL_PROMPT = Template(
+'''Below is an exchange between a user and an agent. The user has asked the agent 
+"$user_query". The agent is completing the users request by calling a function or 
+functions. Complete the exchange by either:
+
+1. Calling the next function needed to get the information necessary to generate a 
+final answer for the user.
+2. Generating the final answer if you have enough information to do so already.
+
+If no more information is needed to generate the final answer, do so without calling
+additional tools.
+
+agent: $prior_reply
+
+user: $user_query
+
+agent: $intermediate_reply
+
+function call: $tool_name($tool_parameters)
+
+function return: $tool_result
+'''
+)
+
+
+'''Here is an example exchange between the user and agent using a single function call:
+
+user: Give me a summary of the article "Apple announces Foundation Models and 
+Containerization frameworks"?
+
+agent: OK, I will summarize the article.
+
+function call: get_summary("Apple announces Foundation Models and Containerization frameworks")
+
+function return: {"summary": "Apple announced new technologies and enhancements to its 
+developer tools to help create more beautiful, intelligent, and engaging app experiences
+across Apple platforms, including a new software design and access to on-device Apple 
+Intelligence and large language models."}
+
+assistant: Apple announced new technologies and enhancements to its developer tools to 
+help create more beautiful, intelligent, and engaging app experiences across Apple 
+platforms, including a new software design and access to on-device Apple Intelligence 
+and large language models.'''

client/tool_workflows.py

@@ -0,0 +1,215 @@
+'''Functions to handle re-prompting and final reply generation
+downstream of LLM tool calls.'''
+
+import json
+import logging
+import queue
+from anthropic.types import text_block
+from client import prompts
+from client.anthropic_bridge import AnthropicBridge
+
+INTERMEDIATE_REPLY_HINTS = {
+    'rss_mcp_server_context_search': 'Let me find some additional context before I generate a final answer.',
+    'rss_mcp_server_find_article': 'I will find the title of that article.',
+    'rss_mcp_server_get_summary': 'I will summarize that article',
+    'rss_mcp_server_get_link': 'I will get the link to that article'
+}
+
+async def tool_loop(
+        user_query: str,
+        prior_reply: str,
+        result: list,
+        bridge: AnthropicBridge,
+        output_queue: queue.Queue,
+        dialog: logging.Logger
+) -> None:
+
+    '''Re-prompts the LLM in a loop until it generates a final reply based on tool output.
+
+    Args:
+        user_query: the original user input that provoked the tool call
+        result: the complete model reply containing the tool call
+        bridge: AnthropicBridge class instance
+        output_queue: queue to send results back to Gradio UI
+        dialog: logger instance to record intermediate responses and internal dialog
+    '''
+
+    tool_call = result['tool_call']
+    tool_name = tool_call['name']
+
+    if tool_name == 'rss_mcp_server_get_feed':
+        reply = await get_feed_call(
+            user_query,
+            result,
+            bridge,
+            output_queue,
+            dialog
+        )
+
+        output_queue.put(reply)
+
+    else:
+        tool_call = result['tool_call']
+        tool_name = tool_call['name']
+        tool_parameters = tool_call['parameters']
+        response_content = result['llm_response'].content[0]
+
+        if isinstance(response_content, text_block.TextBlock):
+            intermediate_reply = response_content.text
+        else:
+            intermediate_reply = INTERMEDIATE_REPLY_HINTS[tool_name]
+
+        dialog.info('LLM intermediate reply: %s', intermediate_reply)
+        dialog.info('MCP: called %s', tool_name)
+
+        tool_result = json.loads(result['tool_result'].content)['text']
+
+        prompt = prompts.OTHER_TOOL_PROMPT.substitute(
+            user_query=user_query,
+            prior_reply=prior_reply,
+            intermediate_reply=intermediate_reply,
+            tool_name=tool_name,
+            tool_parameters=tool_parameters,
+            tool_result=tool_result
+        )
+
+        dialog.info('System: re-prompting LLM with return from %s call', tool_name)
+
+        while True:
+
+            reply = await other_call(
+                prompt,
+                bridge,
+                dialog
+            )
+
+            if 'final reply' in reply:
+                final_reply = reply['final reply']
+                dialog.info('LLM final reply: %s ...', final_reply[:50])
+                output_queue.put(final_reply)
+                break
+
+            else:
+                prompt = reply['new_prompt']
+
+
+async def get_feed_call(
+        user_query: str,
+        result: list,
+        bridge: AnthropicBridge,
+        output_queue: queue.Queue,
+        dialog: logging.Logger
+) -> str:
+
+    '''Re-prompts LLM after a call to get_feed().
+    
+    Args:
+        user_query: the original user input that provoked the tool call
+        result: the complete model reply containing the tool call
+        bridge: AnthropicBridge class instance
+        output_queue: queue to send results back to Gradio UI
+        dialog: logger instance to record intermediate responses and internal dialog
+    '''
+
+    tool_call = result['tool_call']
+    tool_name = tool_call['name']
+    tool_parameters = tool_call['parameters']
+    website = tool_parameters['website']
+    response_content = result['llm_response'].content[0]
+
+    if isinstance(response_content, text_block.TextBlock):
+        intermediate_reply = response_content.text
+    else:
+        intermediate_reply = f'I Will check the {website} RSS feed for you'
+
+    dialog.info('LLM intermediate reply: %s', intermediate_reply)
+    dialog.info('MCP: called %s on %s', tool_name, website)
+
+    articles = json.loads(result['tool_result'].content)['text']
+
+    prompt = prompts.GET_FEED_PROMPT.substitute(
+        website=website,
+        user_query=user_query,
+        intermediate_reply=intermediate_reply,
+        articles=articles
+    )
+
+    input_message =[{
+        'role': 'user',
+        'content': prompt
+    }]
+
+    dialog.info('System: re-prompting LLM with return from %s call', tool_name)
+
+    result = await bridge.process_query(
+        prompts.REPROMPTING_SYSTEM_PROMPT,
+        input_message
+    )
+
+    try:
+
+        reply = result['llm_response'].content[0].text
+
+    except (IndexError, AttributeError):
+        reply = 'No final reply from model'
+
+    dialog.info('LLM final reply: %s ...', reply[:50])
+
+    output_queue.put(reply)
+
+
+async def other_call(
+        prompt: list[dict],
+        bridge: AnthropicBridge,
+        dialog: logging.Logger
+) -> dict:
+
+    '''Re-prompts LLM after a call to get_feed().
+    
+    Args:
+        prompt: prompt to to send the LLM
+        result: the complete model reply containing the tool call
+        bridge: AnthropicBridge class instance
+        output_queue: queue to send results back to Gradio UI
+        dialog: logger instance to record intermediate responses and internal dialog
+    '''
+
+    input_message =[{
+        'role': 'user',
+        'content': prompt
+    }]
+
+    result = await bridge.process_query(
+        prompts.REPROMPTING_SYSTEM_PROMPT,
+        input_message
+    )
+
+    if result['tool_result']:
+
+        tool_call = result['tool_call']
+        tool_name = tool_call['name']
+        tool_parameters = tool_call['parameters']
+        response_content = result['llm_response'].content[0]
+
+        if isinstance(response_content, text_block.TextBlock):
+            intermediate_reply = response_content.text
+        else:
+            intermediate_reply = INTERMEDIATE_REPLY_HINTS[tool_name]
+
+        dialog.info('LLM intermediate reply: %s', intermediate_reply)
+        dialog.info('MCP: called %s', tool_name)
+
+        tool_result = json.loads(result['tool_result'].content)['text']
+
+        prompt += f'agent: {intermediate_reply}\n'
+        prompt += f'function call: {tool_name}("{tool_parameters}")'
+        prompt += f'function return: {tool_result}'
+
+        dialog.info('System: re-prompting LLM with return from %s call', tool_name)
+
+        return {'new_prompt': prompt}
+
+    else:
+
+        reply = result['llm_response'].content[0].text
+        return {'final reply': reply}

rss_client.py

@@ -23,7 +23,7 @@ Path('logs').mkdir(parents=True, exist_ok=True)
 # Clear old logs if present
 gradio_funcs.delete_old_logs('logs', 'rss_client')
 
-# Configure
+# Configure the root logger
 logging.basicConfig(
     handlers=[RotatingFileHandler(
         'logs/rss_client.log',
@@ -31,7 +31,7 @@ logging.basicConfig(
         backupCount=10,
         mode='w'
     )],
-    level=logging.DEBUG,
+    level=logging.INFO,
     format='%(levelname)s - %(name)s - %(message)s'
 )
 
@@ -40,8 +40,7 @@ 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',
-    #'http://127.0.0.1:7861/gradio_api/mcp/sse'
+    'https://agents-mcp-hackathon-rss-mcp-server.hf.space/gradio_api/mcp/sse'
 )
 logger.info('Started MCP client')
 
@@ -57,6 +56,7 @@ logger.info('Started Anthropic API bridge')
 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.
 
@@ -93,29 +93,32 @@ def send_message(chat_history: list):
 
         chat_history.append({'role': 'assistant', 'content': ''})
 
-        for character in response:
-            chat_history[-1]['content'] += character
-            time.sleep(0.005)
+        if response is not None:
+
+            for character in response:
+                chat_history[-1]['content'] += character
+                time.sleep(0.005)
 
-            yield chat_history
+                yield chat_history
 
 
-with gr.Blocks(title='MCP RSS client') as demo:
+with gr.Blocks(title='RASS agent') as demo:
     with gr.Row():
         gr.HTML(html.TITLE)
 
     gr.Markdown(html.DESCRIPTION)
+    gr.Markdown(html.FEATURES_TOOLS)
 
     # MCP connection/tool dump
     connect_btn = gr.Button('Connect to MCP server')
-    status = gr.Textbox(label='MCP server tool dump', interactive=False, lines=4)
+    status = gr.Textbox(label='MCP server tool dump', interactive=False, lines=5, max_lines=5)
     connect_btn.click(# pylint: disable=no-member
         RSS_CLIENT.list_tools,
         outputs=status
     )
 
     # Dialog log output
-    dialog_output = gr.Textbox(label='Internal dialog', lines=10, max_lines=100)
+    dialog_output = gr.Textbox(label='Internal dialog', lines=5, max_lines=5)
     timer = gr.Timer(0.5, active=True)
 
     timer.tick( # pylint: disable=no-member
@@ -132,9 +135,9 @@ with gr.Blocks(title='MCP RSS client') as demo:
     )
 
     msg = gr.Textbox(
-        'Are there any new posts on Hacker News?',
+        'Are there any new posts on Slashdot?',
         label='Ask about content or articles on a site or platform',
-        placeholder='Is there anything new on Hacker News?',
+        placeholder='Is there anything new on Slashdot?',
         scale=4
     )
 
@@ -148,6 +151,7 @@ with gr.Blocks(title='MCP RSS client') as demo:
 if __name__ == '__main__':
 
     current_directory = os.getcwd()
+    logger.info(current_directory)
 
     if 'pyrite' in current_directory:
         logger.info('Starting RASS on LAN')