# OpenAI Function Calling Example
import openai

# 1. Define tools in your request
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string"}
            }
        }
    }
}]

# 2. LLM returns structured function call
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Weather in Seattle?"}],
    tools=tools
)

# 3. Your code executes the function
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    # Execute get_weather(location="Seattle")

# MCP Server (Python)
from mcp.server import Server
from mcp.types import Tool

server = Server("weather-server")

# 1. Server exposes tools
@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="get_weather",
            description="Get current weather",
            inputSchema={
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                }
            }
        )
    ]

# 2. Server handles tool execution
@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_weather":
        return get_weather(arguments["location"])

# Conceptual flow: MCP + Function Calling

# 1. MCP client discovers tools from server
tools = mcp_client.list_tools()

# 2. Tools converted to function schemas for LLM
function_schemas = convert_mcp_to_functions(tools)

# 3. LLM uses function calling to select tool
response = llm.chat(
    messages=messages,
    functions=function_schemas
)

# 4. MCP client routes to appropriate server
result = mcp_client.call_tool(
    name=response.tool_call.name,
    arguments=response.tool_call.arguments
)

# 5. Result returned to LLM