MCP vs. Function Calling APIs: Open Standard vs. Proprietary Tools

import os
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
import datetime
import requests
import json

# --- MCP Tool Server (FastAPI) ---
app = FastAPI(title="Time Tool MCP Server")

class ToolCallRequest(BaseModel):
    tool_name: str
    arguments: dict

@app.get("/tools")
async def discover_tools():
    return {
        "tools": [
            {
                "name": "get_current_time",
                "description": "Returns the current UTC timestamp.",
                "input_schema": {"type": "object", "properties": {}},
                "output_schema": {"type": "object", "properties": {"current_time": {"type": "string"}}}
            }
        ]
    }

@app.post("/call")
async def call_tool(request: ToolCallRequest):
    if request.tool_name == "get_current_time":
        return {"current_time": datetime.datetime.utcnow().isoformat() + "Z"}
    raise HTTPException(status_code=404, detail="Tool not found")

# --- MCP Client (Agent Simulation) ---
def simulate_mcp_agent_interaction(mcp_server_url: str):
    print("
--- MCP Agent Interaction ---")
    print(f"Discovering tools from {mcp_server_url}/tools")
    try:
        discovery_response = requests.get(f"{mcp_server_url}/tools")
        discovery_response.raise_for_status()
        tools_data = discovery_response.json()
        print("Discovered tools:", json.dumps(tools_data, indent=2))

        if any(tool['name'] == 'get_current_time' for tool in tools_data['tools']):
            print("Invoking 'get_current_time' tool...")
            call_response = requests.post(
                f"{mcp_server_url}/call",
                json={"tool_name": "get_current_time", "arguments": {}}
            )
            call_response.raise_for_status()
            result = call_response.json()
            print("Tool invocation result:", result)
        else:
            print("get_current_time tool not found.")
    except requests.exceptions.RequestException as e:
        print(f"Error during MCP interaction: {e}")

# To run the server and then simulate the client:
# 1. Start the FastAPI server in a separate process:
#    uvicorn your_script_name:app --port 8000
# 2. Then run the client simulation:
#    simulate_mcp_agent_interaction("http://localhost:8000")

# Example of how to run the client simulation if the server is already running:
# if __name__ == "__main__":
#     # This part is for demonstration. In a real scenario, server runs separately.
#     # You would run 'uvicorn your_script_name:app --port 8000' in one terminal
#     # and then run this script from another terminal.
#     # For this runnable example, we'll assume the server is not running and just show the client logic.
#     print("To run the MCP server: uvicorn your_script_name:app --port 8000")
#     print("Then, run the client simulation by calling simulate_mcp_agent_interaction('http://localhost:8000')")
#     # simulate_mcp_agent_interaction("http://localhost:8000") # Uncomment to test if server is up

import os
import openai
import json
import datetime

# --- Function Calling Tool Definition ---
def get_current_time_function():
    """Returns the current UTC timestamp."""
    return {"current_time": datetime.datetime.utcnow().isoformat() + "Z"}

# Tool schema for OpenAI's API
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "Returns the current UTC timestamp.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    }
]

# --- OpenAI Agent Interaction ---
def simulate_function_calling_agent_interaction():
    print("
--- Function Calling Agent Interaction ---")
    client = openai.OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

    messages = [{
        "role": "user",
        "content": "What is the current time?"
    }]

    print("Sending initial request to LLM with tool definitions...")
    response = client.chat.completions.create(
        model="gpt-4o", # Or another model supporting function calling
        messages=messages,
        tools=tools,
        tool_choice="auto",
    )

    response_message = response.choices[0].message
    messages.append(response_message)

    if response_message.tool_calls:
        print("LLM requested tool call:", json.dumps([tc.model_dump() for tc in response_message.tool_calls], indent=2))
        tool_call = response_message.tool_calls[0]
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)

        if function_name == "get_current_time":
            print("Executing 'get_current_time' function locally...")
            function_response = get_current_time_function()
            print("Function response:", function_response)

            messages.append({
                "tool_call_id": tool_call.id,
                "role": "tool",
                    "content": json.dumps(function_response),
            })

            print("Sending tool response back to LLM...")
            second_response = client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
            )
            print("Final LLM response:", second_response.choices[0].message.content)
        else:
            print(f"Unknown tool requested: {function_name}")
    else:
        print("LLM did not request a tool call. Final response:", response_message.content)

if __name__ == "__main__":
    # Set your OpenAI API key as an environment variable
    # os.environ["OPENAI_API_KEY"] = "sk-..."
    if not os.environ.get("OPENAI_API_KEY"):
        print("Please set the OPENAI_API_KEY environment variable.")
    else:
        simulate_function_calling_agent_interaction()