# math_server.py

from mcp.server.fastmcp import FastMCP



mcp = FastMCP("Math")



@mcp.tool()

def add(a: int, b: int) -> int:

    """Add two numbers"""

    return a + b



@mcp.tool()

def multiply(a: int, b: int) -> int:

    """Multiply two numbers"""

    return a * b



if __name__ == "__main__":

    mcp.run()

# Create server parameters for stdio connection

from mcp import ClientSession, StdioServerParameters

from mcp.client.stdio import stdio_client

from langchain_mcp_adapters.tools import load_mcp_tools

from langgraph.prebuilt import create_react_agent



from langchain_openai import ChatOpenAI

from dotenv import load_dotenv

import os



from typing import Dict, List, Union

from langchain.schema import AIMessage, HumanMessage



def extract_ai_message_content(response: Dict[str, List[Union[AIMessage, HumanMessage]]]) -> str:

    for message in response.get('messages', []):

        if isinstance(message, AIMessage) and message.content:

            return message.content

    return ""  # Return empty string if no non-empty AIMessage is found



load_dotenv()



model = ChatOpenAI(model="gpt-4o")

import asyncio 



server_params = StdioServerParameters(

    command="python",

    # Make sure to update to the full absolute path to your math_server.py file

    args=["server.py"],

)



async def main():

    async with stdio_client(server_params) as (read, write):

        async with ClientSession(read, write) as session:

            # Initialize the connection

            await session.initialize()



            # Get tools

            tools = await load_mcp_tools(session)



            # Create and run the agent

            agent = create_react_agent(model, tools)

            agent_response = await agent.ainvoke({"messages": "what's (5000 + 18) then calculate 12x12 ?"})

            print(extract_ai_message_content(agent_response))



asyncio.run(main())

import asyncio

import os

from langchain_mcp_adapters.client import MultiServerMCPClient

from langgraph.prebuilt import create_react_agent

from langchain_openai import ChatOpenAI

from dotenv import load_dotenv



from typing import Dict, List, Union

from langchain.schema import AIMessage, HumanMessage



def extract_ai_message_content(response: Dict[str, List[Union[AIMessage, HumanMessage]]]) -> str:

    for message in response.get('messages', []):

        if isinstance(message, AIMessage) and message.content:

            return message.content

    return ""  # Return empty string if no non-empty AIMessage is found



load_dotenv()



model = ChatOpenAI(model="gpt-4o")



async def run_dynamic_directory_agent(directory):

    async with MultiServerMCPClient() as client:

        await client.connect_to_server(

            "filesystem",

            command="npx",

            args=["-y", "@modelcontextprotocol/server-filesystem", directory]

        )



        agent = create_react_agent(model, client.get_tools())



        response = await agent.ainvoke({"messages": f"List files in the directory: {directory}"})

        print(extract_ai_message_content(response))



def get_user_directory():

    while True:

        directory = input("Enter the directory path (or press Enter for current directory): ").strip()

        if directory == "":

            return os.getcwd()

        elif os.path.isdir(directory):

            return os.path.abspath(directory)

        else:

            print("Invalid directory. Please try again.")



def main():

    user_directory = get_user_directory()

    print(f"Using directory: {user_directory}")

    asyncio.run(run_dynamic_directory_agent(user_directory))



if __name__ == "__main__":

    main()