1. 사용자 메시지 + 툴 스펙 → LLM
2. LLM → "이 툴을 이 인자로 호출하라" (JSON 형태 출력)
3. 런타임이 실제 함수 실행
4. 실행 결과 → LLM에게 다시 전달
5. LLM → 최종 자연어 답변 생성

from openai import OpenAI
import json

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "특정 종목의 현재 주가를 조회합니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "주식 티커 (예: AAPL, TSLA)"
                    },
                    "currency": {
                        "type": "string",
                        "enum": ["USD", "KRW"]
                    }
                },
                "required": ["symbol"]
            }
        }
    }
]

def get_stock_price(symbol, currency="USD"):
    return {"symbol": symbol, "price": 192.5, "currency": currency}

def run_agent(user_message):
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if msg.tool_calls is None:
            return msg.content

        for tc in msg.tool_calls:
            args = json.loads(tc.function.arguments)
            result = get_stock_price(**args)
            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": json.dumps(result)
            })

import anthropic, json

client = anthropic.Anthropic()

tools = [{
    "name": "search_docs",
    "description": "내부 문서 데이터베이스에서 관련 문서를 검색합니다",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string"},
            "max_results": {"type": "integer", "default": 5}
        },
        "required": ["query"]
    }
}]

def search_docs(query, max_results=5):
    return [{"title": "API 인증 가이드", "content": "Bearer 토큰 방식을 사용합니다..."}]

messages = [{"role": "user", "content": "우리 API 인증 방식이 어떻게 돼?"}]

while True:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )

    if response.stop_reason == "end_turn":
        text_block = next(b for b in response.content if b.type == "text")
        print(text_block.text)
        break

    messages.append({"role": "assistant", "content": response.content})

    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = search_docs(**block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result, ensure_ascii=False)
            })
    messages.append({"role": "user", "content": tool_results})

# MCP 서버 구현
from mcp.server import Server
import mcp.types as types

server = Server("my-tools-server")

@server.list_tools()
async def handle_list_tools():
    return [
        types.Tool(
            name="query_database",
            description="SQL 쿼리를 실행하고 결과를 반환합니다",
            inputSchema={
                "type": "object",
                "properties": {
                    "sql": {"type": "string", "description": "실행할 SELECT 쿼리"}
                },
                "required": ["sql"]
            }
        )
    ]

@server.call_tool()
async def handle_call_tool(name, arguments):
    if name == "query_database":
        results = execute_query(arguments["sql"])
        return [types.TextContent(type="text", text=str(results))]

import asyncio

async def execute_tools_parallel(tool_calls):
    tasks = [dispatch_tool(tc.function.name, json.loads(tc.function.arguments))
             for tc in tool_calls]
    return await asyncio.gather(*tasks)