MCP 协议 + 大模型 tools 调用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from mcp import ClientSession, StdioServerParameters, types
from mcp.client.stdio import stdio_client

# Create server parameters for stdio connection
server_params = StdioServerParameters(
    command="python",  # Executable
    args=["example_server.py"],  # Optional command line arguments
    env=None,  # Optional environment variables
)
async def run():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(
            read, write, sampling_callback=handle_sampling_message
        ) as session:
            # Initialize the connection
            await session.initialize()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from mcp.client.streamable_http import streamablehttp_client
from mcp import ClientSession


async def main():
    # Connect to a streamable HTTP server
    async with streamablehttp_client("example/mcp") as (
        read_stream,
        write_stream,
        _,
    ):
        # Create a session using the client streams
        async with ClientSession(read_stream, write_stream) as session:
            # Initialize the connection
            await session.initialize()
            # Call a tool
            tool_result = await session.call_tool("echo", {"message": "hello"})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# -*- coding: utf-8; -*-
import contextlib
import math
import random
from typing import Any

from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP


mcp_app = FastMCP("model predicting")


@mcp_app.tool()
def temperature_predict(longitude: float, lattitude: float) -> float:
    """"""
    return random.random()


# Create a combined lifespan to manage both session managers
@contextlib.asynccontextmanager
async def lifespan(app: FastAPI):
    async with contextlib.AsyncExitStack() as stack:
        await stack.enter_async_context(mcp_app.session_manager.run())
        # await stack.enter_async_context(math.mcp.session_manager.run())
        yield


app = FastAPI(lifespan=lifespan) # 注意这里必须使用 lifespan=lifespan 初始化 FastMCP session


app.mount("/model_predict", mcp_app.streamable_http_app())

if __name__ == '__main__':
    mcp_app.run(transport="streamable-http", )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# -*- coding: utf-8; -*-
from mcp import ClientSession, StdioServerParameters, types
from mcp.client.streamable_http import streamablehttp_client


async def main():
    async with streamablehttp_client("http://localhost:8044/model_predict/mcp") as (sread, swrite, _): # 使用 fastapi 运行 server
    # async with streamablehttp_client("http://localhost:8000/mcp") as (sread, swrite, _): # 使用 FastMCP.run() 运行server
        async with ClientSession(sread, swrite) as session:
            await session.initialize()
            # print(await session.list_prompts())
            print(await session.list_tools())

if __name__ == '__main__':
    import asyncio
    asyncio.run(main())

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

# -*- coding: utf-8; -*-
import json

import openai
from mcp import ClientSession, StdioServerParameters, types
from mcp.client.streamable_http import streamablehttp_client

# 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


def convert_tool_format(tool):
    converted_tool = {
        "type": "function",
        "function": {
            "name": tool.name,
            "description": tool.description,
            "parameters": {
                "type": "object",
                "properties": tool.inputSchema["properties"],
                "required": tool.inputSchema["required"],
            },
        },
    }
    return converted_tool


async def main():
    async with streamablehttp_client("http://localhost:8044/model_predict/mcp") as (
        sread,
        swrite,
        _,
    ):
        # async with streamablehttp_client("http://localhost:8000/mcp") as (sread, swrite, _):
        async with ClientSession(sread, swrite) as session:
            await session.initialize()
            # print(await session.list_prompts())
            resp_tools = await session.list_tools()
            print(resp_tools.tools)
            available_tools = [convert_tool_format(t) for t in resp_tools.tools]

            print(f"{available_tools = }")
            tool_result = await session.call_tool(
                "temperature_predict",
                arguments={"longitude": 88.88, "lattitude": 10.10},
            )

            print(f"{tool_result = }\n {tool_result.content}")
            base_url="https://openrouter.ai/api/v1",
            api_key="<YOUR API KEY>",
            # MODEL="deepseek/deepseek-r1-0528:free",
            MODEL = "openai/gpt-4o-mini"

            base_url = "https://api.siliconflow.cn/v1"
            api_key="<YOUR API KEY>",
            MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
            MODEL = "deepseek-ai/DeepSeek-V3"

            openai_client = openai.OpenAI(
                base_url=base_url,
                api_key=api_key,
            )
            messages = [
                {
                    "role": "user",
                    "content": "I want to take part in a party at (100, 88) of longittude and lattitude, Give me some wearing suggestions based on the temperature",
                }
            ]

            completion = openai_client.chat.completions.create(
                tools=available_tools,
                model=MODEL,
                messages=messages,
            )
            resp = completion.choices[0].message
            messages.append(resp.model_dump())
            print(f"{resp = }")

            # resp = {'content': '', 'refusal': None, 'role': 'assistant', 'annotations': None, 'audio': None, 'function_call': None, 'tool_calls': [{'id': 'call_Lwe5euiu0sH8R4kg9CZYL5jp', 'function': {'arguments': '{"longitude":100,"lattitude":88}', 'name': 'temperature_predict'}, 'type': 'function', 'index': 0}], 'reasoning': None}
            if resp.tool_calls:
                tool_name = resp.tool_calls[0].function.name
                tool_args = resp.tool_calls[0].function.arguments
                if tool_args:
                    tool_args = json.loads(tool_args)
                else:
                    tool_args = {}

                try:
                    tool_result = await session.call_tool(
                        name=tool_name, arguments=tool_args
                    )
                except Exception as e:
                    print(e)
                    tool_result = None

                print(f"\n\n{tool_result = }")

                if tool_result:
                    if isinstance(tool_result.content, str):
                        content = tool_result.content
                    elif isinstance(tool_result.content, list):
                        content = tool_result.content[0]
                        if not isinstance(content, str):
                            content = content.text

                    messages.append(
                        {
                            "role": "tool",
                            "content": content,
                            "tool_call_id": resp.tool_calls[0].id, # 必须提供
                            "name": tool_name,
                        }
                    )

                    print(f'\n\n{messages[-1] = }\n')
                    resp = openai_client.chat.completions.create(
                        model=MODEL,
                        messages=messages,
                    )
                    print(f"\n\n{resp = }")

                    messages.append(resp.choices[0].message.model_dump())

                    print(f'--'*10)
                    from pprint import pprint
                    pprint(messages)


if __name__ == "__main__":
    import asyncio

    asyncio.run(main())