Add Tool Calling and MCP content

Author: raghavbali

docs/assets/04_llm_mcp.png

@@ -0,0 +1,36 @@
+
+import os
+import json
+from fastmcp import FastMCP
+from scraper_utils import NB_Markdown_Scraper
+
+mcp = FastMCP(
+    name="Calculation Server",
+    instructions="""
+        This server provides mathematical capabilities
+        """,)
+
+@mcp.tool
+def greet(self,name: str= None):
+    '''Greets the User'''
+    if not name:
+        return "Hi, I am NotebookServer"
+    else:
+        return f"Hi {name}, I am NotebookServer"
+
+@mcp.tool
+def add_two_numbers(a: int, b: int) -> int:
+    """
+    Add two numbers
+    Args:
+        a: The first integer number
+        b: The second integer number
+    
+    Returns:
+        int: The sum of the two numbers
+    """
+    return a + b
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    mcp.run(transport='stdio')

docs/assets/04_mcp.png

@@ -0,0 +1,42 @@
+import asyncio
+from fastmcp import Client, FastMCP
+
+# In-memory server (ideal for testing)
+server = FastMCP("TestServer")
+client = Client(server)
+
+# HTTP server
+client = Client("https://example.com/mcp")
+
+# Local Python script
+client = Client("notebook_server.py")
+
+async def main():
+    async with client:
+        # Basic server interaction
+        await client.ping()
+        
+        # List available operations
+        tools = await client.list_tools()
+        resources = await client.list_resources()
+        prompts = await client.list_prompts()
+        
+        print("-"*30)
+        print("Tools:")
+        print("-"*30)
+        print(tools)
+        print("-"*30)
+        print("Resources:")
+        print("-"*30)
+        print(resources)
+        print("-"*30)
+        print("Prompts:")
+        print(prompts)
+        print("-"*30)
+        # Execute operations
+        await client.call_tool("scrape_markdowns", {})
+        result = await client.call_tool("write_json", {"file_name":"test_mcp_server.json"})
+        print("-"*30)
+        print(f"Result of tool call for write_json:\n{result}")
+
+asyncio.run(main())

docs/assets/04_tool_calling.png

@@ -0,0 +1,121 @@
+from mcp import ClientSession, StdioServerParameters, types
+from mcp.client.stdio import stdio_client
+from typing import List
+import asyncio
+import nest_asyncio
+# from ollama import Client
+import ollama
+
+
+nest_asyncio.apply()
+
+class MCP_ChatBot:
+
+    def __init__(self):
+        # Initialize session and client objects
+        self.session: ClientSession = None
+        self.available_tools: List[dict] = []
+        # self.open_ai_compat_client = Client(
+        #     host='http://localhost:11434',
+        #     # headers={'x-some-header': 'some-value'}
+        # )
+        self.model_name = 'llama3.1'
+
+    async def process_query(self, query):
+        messages = [{'role':'user', 'content':query}]
+        response = ollama.chat(
+            model=self.model_name, 
+            messages=messages,tools=self.available_tools) #self.open_ai_compat_client
+        process_query = True
+        print(response)
+        while process_query:
+            assistant_content = []
+            # for content in response.message.content:
+            content = response.message.content
+            tool_calls = response.message.tool_calls
+            
+            if not tool_calls:
+                print("No tool calls detected")
+                assistant_content.append(content)
+                if(len(response.message.content) >1):
+                    process_query= False
+            elif tool_calls:
+                print(" tool calls detected")
+                assistant_content.append(content)
+                messages.append({'role':'assistant', 'content':assistant_content})
+                tool_args = tool_calls.function.arguments
+                tool_name = tool_calls.function.name
+
+                print(f"Calling tool {tool_name} with args {tool_args}")
+                
+                # Call a tool
+                # tool invocation through the client session
+                result = await self.session.call_tool(tool_name, arguments=tool_args)
+                messages.append({"role": "user", 
+                                  "message": [
+                                      {
+                                          # "tool_use_id":tool_id,
+                                          "content": result.message.content
+                                      }
+                                  ]
+                                })
+                response = self.open_ai_compat_client.chat(model=self.model_name, messages=messages,tools=self.available_tools)                
+                if not response.message.tool_calls:
+                    print(response.message.content)
+                    process_query= False
+
+    
+    
+    async def chat_loop(self):
+        """Run an interactive chat loop"""
+        print("\nMCP Chatbot Started!")
+        print("Type your queries or 'quit' to exit.")
+        
+        while True:
+            try:
+                query = input("\nQuery: ").strip()
+        
+                if query.lower() == 'quit':
+                    break
+                    
+                await self.process_query(query)
+                print("\n")
+                    
+            except Exception as e:
+                print(f"\nError: {str(e)}")
+    
+    async def connect_to_server_and_run(self):
+        # Create server parameters for stdio connection
+        server_params = StdioServerParameters(
+            command="python3",  # Executable
+            args=["calculation_server.py"],  # Optional command line arguments
+            env=None,  # Optional environment variables
+        )
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                self.session = session
+                # Initialize the connection
+                await session.initialize()
+    
+                # List available tools
+                response = await session.list_tools()
+                
+                tools = response.tools
+                print("\nConnected to server with tools:", [tool.name for tool in tools])
+                
+                self.available_tools = [{
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.inputSchema,
+                } for tool in response.tools]
+    
+                await self.chat_loop()
+
+
+async def main():
+    chatbot = MCP_ChatBot()
+    await chatbot.connect_to_server_and_run()
+  
+
+if __name__ == "__main__":
+    asyncio.run(main())

docs/module_04_llm_ops/03_mcp_getting_started.ipynb

@@ -0,0 +1,80 @@
+
+import os
+import json
+from fastmcp import FastMCP
+from scraper_utils import NB_Markdown_Scraper
+
+mcp = FastMCP(
+    name="Notebook Server",
+    instructions="""
+        This server provides a markdown scraper utility
+        and a tool to write JSON file
+        """,)
+
+class NotebookServer():
+    def __init__(self,mcp_instance):
+        self.notebook_scraper = NB_Markdown_Scraper(input_paths=[f'../Users/raghavbali/Documents/raghav/work/github/mastering_llms_workshop/docs/{d}' for d in os.listdir("./Users/raghavbali/Documents/raghav/work/github/mastering_llms_workshop/docs/") if d.startswith("module")])
+        
+        # Register methods  
+        mcp_instance.tool(self.greet)
+        mcp_instance.tool(self.get_notebook_list)
+        mcp_instance.tool(self.get_markdown_from_notebook)
+        mcp_instance.tool(self.notebook_scraper.scrape_markdowns)
+        mcp_instance.tool(self.write_json)
+        mcp_instance.tool(self.add_two_numbers)
+        mcp_instance.resource("resource://data")(self.resource_method)
+
+    def greet(self,name: str= None):
+        '''Greets the User'''
+        if not name:
+            return "Hi, I am NotebookServer"
+        else:
+            return f"Hi {name}, I am NotebookServer"
+    def add_two_numbers(self,a: int, b: int) -> int:
+        """
+        Add two numbers
+        Args:
+            a: The first integer number
+            b: The second integer number
+        
+        Returns:
+            int: The sum of the two numbers
+        """
+        return a + b
+
+    def get_notebook_list(self):
+        '''Returns List of Notebooks Scraped'''
+        return list(self.notebook_scraper.notebook_md_dict.keys())
+
+    def get_markdown_from_notebook(self,notebook_name):
+        '''Returns Markdown Cells for specified notebook'''
+        if notebook_name in list(self.notebook_scraper.notebook_md_dict.keys()):
+            return self.notebook_scraper.notebook_md_dict[notebook_name]
+        else:
+            return f"Requested notebook ({notebook_name}) does not exist"
+        
+    def write_json(self,file_name: str):
+        '''Tool to write a json file in the format notebook:markdown content'''
+        try:
+            with open(f"./{file_name}", "w") as record_file:
+                json.dump(self.notebook_scraper.notebook_md_dict,record_file)
+            return f"File:{file_name} written successfully"
+        except Exception as ex:
+            return f"Could not write {file_name} due to {ex}"
+        
+    
+    def resource_method(self):
+        return """
+        Resources provide read-only access to data for the LLM or client application. When a client requests a resource URI:
+            + FastMCP finds the corresponding resource definition.
+            + If it’s dynamic (defined by a function), the function is executed.
+            + The content (text, JSON, binary data) is returned to the client.
+        This allows LLMs to access files, database content, configuration, or dynamically generated information relevant to the conversation.
+        """
+
+# The methods are automatically registered when creating the instance
+provider = NotebookServer(mcp)
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    mcp.run(transport='stdio')