Adding mcp as a client

.gitignore

@@ -118,3 +118,5 @@ dmypy.json
 
 # Cython debug symbols
 cython_debug/
+
+local-docs

app.py

@@ -27,13 +27,14 @@ from ui.components import (
     create_chapter_accordion,
     create_story_melody_section,
 )
+from ui.mcp_components import mcp_letter_counter
 from controllers.app_controller import (
     generate_audio_with_status,
     generate_melody_from_story_with_status,
 )
-
 from ui.events import setup_event_handlers
 
+
 # Configure logging
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
@@ -147,6 +148,10 @@ def create_app():
                         outputs=[melody_output, melody_status],
                     )
 
+            # TODO DELETE THIS AS IT IRRELEVENT TO STORY GENERATION
+            with gr.Tab("Character Counter"):
+                mcp_letter_counter()
+
         # Set up event handlers
         setup_event_handlers(
             generate_button=generate_button,

requirements.txt

@@ -4,4 +4,7 @@ python-dotenv
 PyPDF2
 typing-extensions
 types-requests
-markdown
+markdown
+mcp
+asyncio
+openai

ui/mcp_components.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from util.mcp_utils import interact_with_openai
+
+
+def mcp_letter_counter():
+    """
+    Count the occurrences of a specific letter in a given word using the MCP server.
+
+    Args:
+        word (str): The word in which to count the letter.
+        letter (str): The letter to count in the word.
+
+    Returns:
+        str: The response from the MCP server containing the count of the letter.
+    """
+    with gr.Column(elem_classes="gr-form") as mcp_letter_counter_ui:
+        gr.HTML("<h2>MCP Character Counter</h2>")
+        gr.HTML("<p>Enter text below and the MCP server will count the characters.</p>")
+
+        # Text input for character counting
+        input_text = gr.Textbox(
+            label="Enter text to count characters",
+            placeholder="Type or paste text here...",
+            lines=5,
+        )
+        letter_to_count = gr.Textbox(
+            label="Letter to Count",
+            placeholder="Enter the letter to count in the text",
+            lines=1,
+        )
+
+        # Count button
+        count_button = gr.Button("Count Characters", variant="primary")
+
+        # Result display
+        result_text = gr.Textbox(label="Result", interactive=False)
+
+        # Connect the button to different counting functions based on method
+        count_button.click(
+            fn=interact_with_openai,  # Use the async function directly - Gradio handles the async
+            inputs=[input_text, letter_to_count],
+            outputs=[result_text],
+        )
+
+        # MCP Tools Explorer Section
+        gr.HTML("<h3>MCP Tools Explorer</h3>")
+        gr.HTML("<p>Explore the available tools in the MCP server.</p>")
+    return mcp_letter_counter_ui

util/mcp_utils.py

@@ -0,0 +1,110 @@
+import json
+import logging
+from mcp.client.sse import sse_client
+from mcp.client.session import ClientSession
+from openai import OpenAI
+import os
+
+logger = logging.getLogger(__name__)
+
+MCP_SERVER_URL = "https://agharsallah-mcp-helper-tool.hf.space/gradio_api/mcp/sse"
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", ""))
+
+
+async def interact_with_openai(word: str, letter: str):
+    """Count occurrences of a letter in text using the MCP server."""
+    try:
+        # Connect to the MCP server using proper async context manager
+        async with sse_client(MCP_SERVER_URL) as (read, write):
+            async with ClientSession(read, write) as session:
+                # Initialize the connection
+                await session.initialize()
+
+                # List available tools from the MCP server
+                try:
+                    response = await session.list_tools()
+                    tools = response.tools
+
+                    logger.info(f"Available tools: {[tool.name for tool in tools]}")
+
+                    # Check if the 'count_letter' tool exists
+                    # update to check if tool.name contains letter_counter
+                    # TODO HERE we are checking the tool by name but we can do this step with LLM
+                    # The LLM will pick the tool name for us that will be used
+                    if not any("letter_counter" in tool.name for tool in tools):
+                        return (
+                            "Error: Tool 'letter_counter' not found on the MCP server.1"
+                        )
+                    # get tool specification
+                    # Check if the 'letter_counter' tool exists
+                    letter_counter_tool = next(
+                        (tool for tool in tools if "letter_counter" in tool.name), None
+                    )
+                    if not letter_counter_tool:
+                        return (
+                            "Error: Tool 'letter_counter' not found on the MCP server.2"
+                        )
+
+                    # Prepare the OpenAI function specification
+                    fn_spec = [
+                        {
+                            "name": letter_counter_tool.name,
+                            "description": letter_counter_tool.description,
+                            "parameters": letter_counter_tool.inputSchema,
+                        }
+                    ]
+                    print(f"Function spec: {fn_spec}")
+                    # let the ai know which tool to use
+                    # Prepare the OpenAI model prompt
+                    messages = [
+                        {
+                            "role": "system",
+                            "content": "You can call the 'count_letter' function to count the occurrences of a letter in a word.",
+                        },
+                        {
+                            "role": "user",
+                            "content": f'How many times does the letter "{letter}" appear in the word "{word}"?',
+                        },
+                    ]
+                    formatted_tools = [{"type": "function", **spec} for spec in fn_spec]
+                    # OpenAI function-call completion
+                    first_response = client.responses.create(
+                        model="gpt-4o-mini",  # Choose the right OpenAI model
+                        input=messages,
+                        tools=formatted_tools,
+                        tool_choice="auto",
+                    )
+                    logger.info(f"OpenAI response: {first_response.output}")
+                    # Check if the response contains a tool call
+                    tool_call = first_response.output[0]
+
+                    if tool_call:
+                        logger.info(f"Tool call: {tool_call}")
+                        # Call the MCP tool with the provided parameters
+                        tool_response = await session.call_tool(
+                            name=tool_call.name,
+                            arguments=json.loads(tool_call.arguments),
+                        )
+                        logger.info(f"Tool response: {tool_response}")
+                        # Extract the result from the tool response
+                        # TODO THE cool thing is that you can send the response back to the AI
+                        # and let it parse the response
+                        # and return the result
+                        if tool_response.content:
+                            try:
+                                result = int(
+                                    tool_response.content[0].text
+                                )  # Convert text to int
+                                return result  # Return the integer count
+                            except ValueError:
+                                return "Error: Tool response is not a valid integer."
+                        else:
+                            return "Error: Unexpected tool response format."
+                    else:
+                        return "No tool call found in the OpenAI response."
+                except Exception as inner_e:
+                    logger.error(f"Error in MCP session: {str(inner_e)}", exc_info=True)
+                    return f"Error in MCP session: {str(inner_e)}"
+    except Exception as outer_e:
+        logger.error(f"Error connecting to MCP server: {str(outer_e)}", exc_info=True)
+        return f"Error connecting to MCP server: {str(outer_e)}"