import yfinance as yf
from mcp.server.fastmcp import FastMCP

# 初始化 FastMCP 服务器，并自定义名字
mcp = FastMCP("yahoo-finance")


# 通过 @mcp.tool() 装饰器，定义一个工具函数
@mcp.tool()
async def get_summary(ticker: str) -> str:
    """Get company summary by ticket.

    Args:
        ticker: Company ticker (e.g. AAPL, GOOGL)
    """

    ticker = yf.Ticker(ticker)

    summary = ticker.info["longBusinessSummary"]

    return summary.strip()


@mcp.tool()
async def get_news(ticker: str) -> str:
    """Get company news by ticket.

    Args:
        ticker: Company ticker (e.g. AAPL, GOOGL)
    """

    ticker = yf.Ticker(ticker)
    news = ticker.news
    return "\n\n".join([f"{n['content']['summary']}\n{n['content']['canonicalUrl']['url']}" for n in news])


if __name__ == "__main__":
    mcp.run(transport='stdio')

import asyncio
import os
from contextlib import AsyncExitStack
from typing import Optional

from anthropic import Anthropic
from dotenv import load_dotenv
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

load_dotenv()


class MCPClient:
    def __init__(self):
        # Initialize session and client objects
        self.session: Optional[ClientSession] = None
        self.exit_stack = AsyncExitStack()
        self.anthropic = Anthropic()
        self.model = os.getenv("ANTHROPIC_MODEL")

    async def connect_to_server(self, server_script_path: str):
        """连接到 MCP 服务器
        
        参数:
            server_script_path: 服务器脚本路径 (.py or .js)
        """
        is_python = server_script_path.endswith('.py')
        is_js = server_script_path.endswith('.js')
        if not (is_python or is_js):
            raise ValueError("Server script must be a .py or .js file")

        command = "python" if is_python else "node"
        server_params = StdioServerParameters(
            command=command,
            args=[server_script_path],
            env=None
        )

        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params)) # 使用stdio传输协议构建一个客户端
        self.stdio, self.write = stdio_transport
        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write)) # 初始化会话，通过ClientSession类实现

        await self.session.initialize()

        # 调用list_tools()列出可用工具
        response = await self.session.list_tools()
        tools = response.tools
        print("\nConnected to server with tools:", [tool.name for tool in tools])

    async def process_query(self, query: str) -> str:
        """使用 Claude 和可用工具处理查询"""
        messages = [
            {
                "role": "user",
                "content": query # 用户提问
            }
        ]
	
  			# 通过会话获取目前 MCP 服务器支持的工具列表
        response = await self.session.list_tools()
      	# 转成 Claude 模型支持的工具列表参数
        available_tools = [{
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.inputSchema
        } for tool in response.tools]

        # 初始化 Claude API 调用
        response = self.anthropic.messages.create(
            model=self.model,
            max_tokens=1000,
            messages=messages, # 用户的 query 以消息数组的形式交给 messages 参数
            tools=available_tools # 会将目前 MCP 支持的工具交给 tools 参数
        )

        # 处理响应和工具调用
        tool_results = []
        final_text = []

        for content in response.content:
            if content.type == 'text':
                final_text.append(content.text)
            # 判断响应中是否有 tool_use 的类型
            elif content.type == 'tool_use':
                tool_name = content.name # 工具名字
                tool_args = content.input # 工具调用参数

                # 再通过 call_tool() 函数 执行工具调用
                result = await self.session.call_tool(tool_name, tool_args)
                tool_results.append({"call": tool_name, "result": result})
                final_text.append(f"[Calling tool {tool_name} with args {tool_args}]")

                # Continue conversation with tool results
                if hasattr(content, 'text') and content.text:
                    messages.append({
                        "role": "assistant",
                        "content": content.text
                    })
                # 告诉模型工具调用的结果
                messages.append({
                    "role": "user",
                    "content": result.content
                })

                # 从 Claude 获取下一个响应
                response = self.anthropic.messages.create(
                    model=self.model,
                    max_tokens=1000,
                    messages=messages,
                )

                final_text.append(response.content[0].text)

        return "\n".join(final_text)

    async def chat_loop(self):
        """Run an interactive chat loop"""
        print("\nMCP Client Started!")
        print("Type your queries or 'quit' to exit.")

        while True:
            try:
                query = input("\nQuery: ").strip()

                if query.lower() == 'quit':
                    break

                response = await self.process_query(query)
                print("\n" + response)

            except Exception as e:
                print(f"\nError: {str(e)}")

    async def cleanup(self):
        """Clean up resources"""
        await self.exit_stack.aclose()


async def main():
    if len(sys.argv) < 2:
      	# 服务器路径
        print("Usage: python client.py <path_to_server_script>")
        sys.exit(1)

    client = MCPClient()
    try:
        await client.connect_to_server(sys.argv[1])
        await client.chat_loop()
    finally:
        await client.cleanup()


if __name__ == "__main__":
    import sys

    asyncio.run(main())

npx @modelcontextprotocol/inspector <command> <arg1> <arg2>

npx @modelcontextprotocol/inspector uv --directory /Users/caihesheng/Desktop/myFiles/code/yahoo-finance run yahoo-finance.py