Improved re-prompting after LLM makes tool call.

client/anthropic_bridge.py

@@ -62,11 +62,13 @@ class LLMBridge(abc.ABC):
 
 
     @abc.abstractmethod
-    async def submit_query(self, query: str, formatted_tools: Any) -> Dict[str, Any]:
+    async def submit_query(self, system_prompt: str, query: List[Dict], formatted_tools: Any) -> Dict[str, Any]:
         '''Submit a query to the LLM with the formatted tools.
 
         Args:
-            query: User query string
+            query: User query string            # messages=[
+            #     {'role': 'user', 'content': query}
+            # ],
             formatted_tools: Tools in the LLM-specific format
             
         Returns:
@@ -101,7 +103,7 @@ class LLMBridge(abc.ABC):
         return await self.mcp_client.invoke_tool(tool_name, kwargs)
 
 
-    async def process_query(self, query: str) -> Dict[str, Any]:
+    async def process_query(self, system_prompt: str, query: List[Dict]) -> Dict[str, Any]:
         '''Process a user query through the LLM and execute any tool calls.
 
         This method handles the full flow:
@@ -125,7 +127,7 @@ class LLMBridge(abc.ABC):
         formatted_tools = await self.format_tools(self.tools)
 
         # 3. Submit query to LLM
-        llm_response = await self.submit_query(query, formatted_tools)
+        llm_response = await self.submit_query(system_prompt, query, formatted_tools)
 
         # 4. Parse tool calls from LLM response
         tool_call = await self.parse_tool_call(llm_response)
@@ -176,7 +178,8 @@ class AnthropicBridge(LLMBridge):
 
     async def submit_query(
             self,
-            query: str,
+            system_prompt: str,
+            query: List[Dict],
             formatted_tools: List[Dict[str, Any]]
     ) -> Dict[str, Any]:
         '''Submit a query to Anthropic with the formatted tools.
@@ -191,10 +194,7 @@ class AnthropicBridge(LLMBridge):
         response = self.llm_client.messages.create(
             model=self.model,
             max_tokens=4096,
-            system='You are a helpful tool-using assistant.',
-            # messages=[
-            #     {'role': 'user', 'content': query}
-            # ],
+            system=system_prompt,
             messages=query,
             tools=formatted_tools
         )

client/interface.py

@@ -2,44 +2,92 @@
 
 import json
 import logging
+from anthropic.types import text_block
 from gradio.components.chatbot import ChatMessage
+
+from client import prompts
 from client.anthropic_bridge import AnthropicBridge
 
-async def agent_input(bridge: AnthropicBridge, chat_history: list) -> list:
+async def agent_input(
+        bridge: AnthropicBridge,
+        chat_history: list
+) -> list:
+
     '''Handles model interactions.'''
 
     function_logger = logging.getLogger(__name__ + '.agent_input')
 
     input_messages = format_chat_history(chat_history)
-    result = await bridge.process_query(input_messages)
-    function_logger.info(result)
+    result = await bridge.process_query(prompts.DEFAULT_SYSTEM_PROMPT, input_messages)
 
-    try:
-        chat_history.append({
-            "role": "assistant",
-            "content": result['llm_response'].content[0].text
-        })
+    if result['tool_result']:
+        tool_call = result['tool_call']
+        tool_name = tool_call['name']
 
-    except AttributeError:
-        function_logger.info('Model called the tool, but did not talk about it')
+        if tool_name == 'rss_mcp_server_get_feed':
 
-    if result['tool_result']:
-        articles = json.loads(result['tool_result'].content)['text']
-        function_logger.info(articles)
-        tmp_chat_history = chat_history.copy()
-        tmp_chat_history.append({
-            "role": "assistant",
-            "content": ('Here are the three most recent entries from the RSS ' +
-                f'feed in JSON format. Tell the user what you have found: {json.dumps(articles)}')
-        })
+            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):
+                intermediate_reply = response_content.text
+            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)
+
+            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
+            }]
+
+            function_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
+
+            except (IndexError, AttributeError):
+                final_reply = 'No final reply from model'
+
+            function_logger.info('LLM final reply: %s', final_reply)
+
+            chat_history.append({
+                "role": "assistant",
+                "content": intermediate_reply
+            })
+
+            chat_history.append({
+                "role": "assistant",
+                "content": final_reply
+            })
+
+    else:
+        try:
+            reply = result['llm_response'].content[0].text
+
+        except AttributeError:
+            reply = 'Bad reply - could not parse'
 
-        tmp_input_messages = format_chat_history(tmp_chat_history)
-        function_logger.info(tmp_input_messages)
-        result = await bridge.process_query(tmp_input_messages)
+        function_logger.info('Direct, no-tool reply: %s', reply)
 
         chat_history.append({
             "role": "assistant",
-            "content": result['llm_response'].content[0].text
+            "content": reply
         })
 
     return chat_history

client/mcp_client.py

@@ -83,8 +83,6 @@ class MCPClientWrapper:
         self.endpoint = endpoint
         self.timeout = timeout
         self.max_retries = max_retries
-        # self.tools = None
-        # self.anthropic = Anthropic()
 
 
     async def _execute_with_retry(self, operation_name: str, operation_func):

client/prompts.py

@@ -0,0 +1,32 @@
+'''Collection of prompts for Claude API calls in different
+conversational contexts.'''
+
+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_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.
+
+user: $user_query
+
+agent: $intermediate_reply
+
+function call: get_feed_content($website)
+
+function return: $articles
+
+assistant:
+'''                       
+)

rss_client.py

@@ -29,17 +29,28 @@ logging.basicConfig(
 
 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'
 )
 
+# Handles Anthropic API I/O
 BRIDGE = AnthropicBridge(
     RSS_CLIENT,
     api_key=os.environ['ANTHROPIC_API_KEY']
 )
 
 async def send_message(message: str, chat_history: list) -> str:
-    '''Submits user message to agent'''
+    '''Submits user message to agent.
+    
+    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 model's response to user added.
+    '''
 
     function_logger = logging.getLogger(__name__ + '.submit_input')
     function_logger.info('Submitting user message: %s', message)
@@ -65,20 +76,26 @@ with gr.Blocks(title='MCP RSS client') as demo:
 
     chatbot = gr.Chatbot(
         value=[],
-        height=500,
+        height=200,
         type='messages',
         show_copy_button=True
     )
 
     msg = gr.Textbox(
+        'Are there any new posts on Hacker News?',
         label='Ask about content or articles on a site or platform',
         placeholder='Is there anything new on Hacker News?',
         scale=4
     )
 
     connect_btn.click(RSS_CLIENT.list_tools, outputs=status) # pylint: disable=no-member
-    msg.submit(send_message, [msg, chatbot], [msg, chatbot]) # pylint: disable=no-member
+
+    msg.submit( # pylint: disable=no-member
+        send_message,
+        [msg, chatbot],
+        [msg, chatbot]
+    )
 
 if __name__ == '__main__':
 
-    demo.launch(debug=True)
+    demo.launch(server_name="0.0.0.0", server_port=7860)