from pydantic import BaseModel, Field
from mcp.server.fastmcp import Context, FastMCP


class InputSchema(BaseModel):
    input: str = Field(description="some infomation")


mcp = FastMCP("my_tool", port=12345)


@mcp.tool()
async def my_tool(prompt: str, ctx: Context) -> str:
    print(f'my_tool:prompt={prompt}')
    result = await ctx.elicit(  # 关键点
        message=(f"Input something about {prompt}"),
        schema=InputSchema,
    )

    print(f'my_tool:result={result}')
    if result.action == "accept" and result.data:
        if result.data.input:
            res = f"[SUCCESS] {prompt}: {result.data.input}"
        else:
            res = "[CANCELLED] No Input"
    else:
        res = "[CANCELLED] Input cancelled"
    return res


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

import asyncio

from mcp import ClientSession
from mcp.types import ElicitResult
from mcp.client.sse import sse_client


async def elicitation_callback(
    context,
    params
):
    print(f'elicitation_callback:context: {context}')
    print(f'elicitation_callback:params: {params}')
    if "Input something about" in params.message:
        result = ElicitResult(
            action="accept",
            content={"input": "def"},
        )
    else:
        result = ElicitResult(action="decline")
    print(f'elicitation_callback:result: {result}')
    return result


async def main():
    mcp_url = 'http://127.0.0.1:12345/sse'

    async with sse_client(url=mcp_url) as streams:
        async with ClientSession(
            *streams,
            elicitation_callback=elicitation_callback  # 关键点
        ) as session:
            await session.initialize()
            result = await session.call_tool(
                'my_tool', {'prompt': 'abc'}
            )
            print(f'\nresult: {result.content[0].text}')


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import sys

from mcp import ClientSession
from mcp.client.sse import sse_client


class FetchMarkdown:
    def __init__(self, mcp_url):
        self.mcp_url = mcp_url

    async def fetch(self, target_url):
        async with sse_client(url=self.mcp_url) as streams:
            async with ClientSession(*streams) as session:
                await session.initialize()
                response = await session.list_tools()
                tools = response.tools
                tool_names = [tool.name for tool in tools]
                print("\nConnected with tools:", tool_names)

                if 'fetch' in tool_names:
                    result = await session.call_tool(
                        'fetch', {'url': target_url}
                    )
                    print(f'\nresult:\n{result.content[0].text}')


async def main():
    mcp_url = (
        sys.argv[1]
        if len(sys.argv) > 1
        else 'https://mcp.api-inference.modelscope.net/xxxxx/sse'
    )
    target_url = sys.argv[2] if len(sys.argv) > 2 else 'https://example.org'
    fetcher = FetchMarkdown(
        mcp_url=mcp_url
    )
    await fetcher.fetch(target_url)


if __name__ == "__main__":
    asyncio.run(main())

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("index", port=8088, log_level='DEBUG')  # 创建 MCP 服务器
g_indexes = []


@mcp.tool()
def build(indexes: list) -> bool:
    global g_indexes
    g_indexes = indexes.copy()
    return True


@mcp.tool()
def query(text: str) -> list:
    return g_indexes + [text]


if __name__ == "__main__":
    mcp.run(transport='sse')  # 启动服务！

# pip install ollama genson

import json
import sys

from ollama import Client
from genson import SchemaBuilder

host = sys.argv[1] if len(sys.argv) > 1 else 'localhost'
model = sys.argv[2] if len(sys.argv) > 2 else 'qwen3-8b'

client = Client(
    host=f'http://{host}:11434'
)
messages = [
    {
        "role": "system",
        "content": """
        你支持以下工具：
        1) 给定函数名获取函数的完整声明。
        请遵守：
        - 当问题涉及未知函数时必用工具
        - 不要解释工具机制
        """
    },
    {
        "role": "user",
        "content": (
            "编写一个演示如何使用make_joke和send_joke的示例程序(sample-code)。"
        )
    }
]


def get_decl(function_name: str):
    functions = {
        "make_joke": 'const std::string& make_joke(void);',
        "send_joke": 'bool send_joke(const std::string& joke);',
    }
    return functions[function_name]


# 定义工具函数注册表
tool_func_map = {
    "get_decl": get_decl,
    # 以后可以加更多工具
}


def build_format(formats):
    builder = SchemaBuilder()
    builder.add_object(formats)
    return builder.to_schema()


def chat(messages, format=None):
    print(json.dumps(messages, ensure_ascii=False, indent=4, default=str))
    response = client.chat(
        model=model,
        messages=messages,
        tools=[
            {
                "function": {
                    "name": "get_decl",
                    "parameters": {
                        "properties": {
                            "function_name": {"type": "string"}
                        },
                        "type": "object",
                    }
                },
                "type": "function",
            }
        ],
        format=format,
    )
    return response


def call_function(response):
    tool_responses = []
    # 正确追加 assistant 回复
    assistant_message = {
        "role": "assistant",
        "content": response['message'].get('content', ''),
        'tool_calls': response['message']['tool_calls']
    }
    tool_responses.append(assistant_message)

    for call in response.message.tool_calls:
        func_name = call.function.name
        func_args = call.function.arguments
        # 动态查找并调用
        if func_name in tool_func_map:
            result = tool_func_map[func_name](**func_args)
        else:
            result = {"error": f"未找到工具函数: {func_name}"}

        tool_responses.append({
            "role": "tool",
            "content": json.dumps(result, ensure_ascii=False),
            'tool_name': call.function.name
        })
    return tool_responses


# 注意：第一次提问期待AI调用工具，这次不能带format。
response = chat(messages)

# 检查是否返回了工具调用指令
if 'tool_calls' in response['message']:
    print(f"✅ {model} 支持工具调用")

    tool_responses = call_function(response)
    messages.extend(tool_responses)

    # 第二次提问，期待AI回复最终答案，这次可以带format
    response = chat(messages, format=build_format({"sample-code": ""}))
    response = response.message.content
    response = json.loads(response)
    print(f"---\n最终回复内容: \n{response['sample-code']}")
else:
    print(f'response={response}')
    print(f"❌ {model} 不支持工具调用")

# 这次尝试使用 openai 的 API
# pip install openai genson

import json
import sys

from openai import OpenAI
from genson import SchemaBuilder

host = sys.argv[1] if len(sys.argv) > 1 else 'localhost:11434'
model = sys.argv[2] if len(sys.argv) > 2 else 'qwen3:32b'

client = OpenAI(
    base_url=f"http://{host}/v1",
    api_key="None"  # 任意字符串（服务端无需认证）
)

messages = [
    {
        "role": "system",
        "content": """
        你支持以下工具：
        1) 给定函数名获取函数的完整声明。

        当你为某个函数（例如A函数）生成单元测试用例时，请遵循以下指导原则：
        1. 使用tools功能获取目标函数（例如A函数）的声明信息。
        2. 在分析该函数的过程中，仔细检查是否存在对其他函数的调用或依赖。这包括但不限于直接函数调用、利用其他函数返回的数据等情况。
        3. 每当识别到一个依赖函数（例如B函数），无论何时何地，在继续生成测试用例之前，立即使用tools功能查询并获取该依赖函数的声明信息。
        4. 将新获取的依赖函数声明信息纳入考量范围，确保生成的测试用例能够正确处理依赖关系，并覆盖所有可能的情况。
        5. 重复步骤2至步骤4，直到完成对该函数及其所有依赖项的分析，并生成完整的单元测试用例。
        """
    },
    {
        "role": "user",
        "content": (
            "已知存在已经实现了的send_joke函数。\n"
            "参照如下设计图编写一个演示如何使用send_joke的示例程序(sample-code)。"
            "如果遇到了任何不存在的函数，请通过tools获取对应的函数声明。\n"
            """
            ```mermaid
            graph TD
                A[make_joke] --> B[send_joke]
                A --> C[print]
                B --> D[print]
            ```
            """
        )
    }
]


def get_decl(function_name: str):
    functions = {
        "make_joke": {
            "decl": 'const std::string& make_joke(void);',
            "header_file": "joke_generator.h"
        },
        "send_joke": {
            "decl": 'bool send_joke(const std::string& joke);',
            "header_file": "joke_generator.h"
        }
    }
    print(f"✅ get_decl({function_name})")
    return functions[function_name]


# 定义工具函数注册表
tool_func_map = {
    "get_decl": get_decl,
    # 以后可以加更多工具
}


def build_format(formats):
    builder = SchemaBuilder()
    builder.add_object(formats)
    return builder.to_schema()


def chat(messages, format=None):
    print(
        '✅ chat:\n' +
        json.dumps(messages, ensure_ascii=False, indent=4, default=str)
    )
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        tools=[
            {
                "function": {
                    "name": "get_decl",
                    "parameters": {
                        "properties": {
                            "function_name": {"type": "string"}
                        },
                        "type": "object",
                    }
                },
                "type": "function",
            }
        ],
        response_format={
            'type': 'json_schema',
            'json_schema':
            {
                "name": 'sample-code',
                "schema": format
            }
        },
    )
    return response.choices[0]


def call_function(response):
    tool_responses = []
    # 正确追加 assistant 回复
    assistant_message = {
        "role": "assistant",
        "content": response.message.content,
        'tool_calls': [
            {
                "id": call.id,
                "type": call.type,
                "function": {
                    "name": call.function.name,
                    "arguments": call.function.arguments
                }
            }
            for call in (response.message.tool_calls or [])
        ]
    }
    tool_responses.append(assistant_message)

    for call in response.message.tool_calls:
        func_name = call.function.name
        func_args = call.function.arguments
        # 如果func_args是字符串，尝试解析为字典
        if isinstance(func_args, str):
            func_args = json.loads(func_args)

        # 动态查找并调用
        if func_name in tool_func_map:
            result = tool_func_map[func_name](**func_args)
        else:
            result = {"error": f"未找到工具函数: {func_name}"}

        tool_responses.append({
            "role": "tool",
            "content": json.dumps(result, ensure_ascii=False),
            'tool_call_id': call.id
        })
    return tool_responses


# 注意：第一次提问期待AI调用工具，这次不能带format。
response = chat(messages)
# 循环处理所有 tool_calls，直到拿到最终 content
while getattr(response.message, "tool_calls", None):
    print(f"✅ {model} 支持工具调用")
    tool_responses = call_function(response)
    messages.extend(tool_responses)
    # 再次提问，如果AI继续调用工具，则循环；
    # 否则，这次回答的是我们的问题，但是不带 format 只能忽略（浪费一次 token )
    response = chat(messages)

# 重新提问，这次附带 format 。
final_prompt = {
    "role": "user",
    "content": (
        "现在你已获取所有依赖函数信息，请生成测试用例，输出格式必须为 JSON。"
    )
}
messages.append(final_prompt)
response = chat(messages, format=build_format({"sample-code": ""}))

res = response.message.content
try:
    res = json.loads(res)
    print(f"---\n最终回复内容: \n{res['sample-code']}")
except json.JSONDecodeError:
    print(f"❌ 无法解析JSON格式的回复: {response}")
    response = {'sample-code': response}

# pip install ollama genson

import json
import os
from ollama import Client
from genson import SchemaBuilder

# 提供一个回答问题的格式模板
# 这里的值（即例子中的0、""和False）并本身不重要，重要的是他们表达了自己的类型
json_data = {
    "Summary": "",
    "Points": [
        {
            "Percent": 0,
            "Abstract": "",
            "Key": False
        }
    ]
}

# 使用 Genson 库生成 JSON Schema
# 这将生成一个标准的 JSON Schema ，描述了 json_data 的结构
builder = SchemaBuilder()
builder.add_object(json_data)
fmt = builder.to_schema()

client = Client(host='http://localhost:11434')
# 简单起见，直接读取本脚本自身作为提示词的一部分
with open(os.path.abspath(__file__), 'rb') as f:
    content = f.read().decode('utf-8')

# 调用 ollama 接口提问
response = client.chat(
    model='qwen3:32b',
    messages=[
        {
            'role': 'user',
            'content': (
                "请对下面代码进行审查。\n"
                "首先，使用一句话，总结一下全文(Summary)。\n"
                "然后，概括出最多不超过3条的摘要(Abstract)，并逐一列出它们。"
                "说明每个摘要占用篇幅的百分比(Percent)及是否为关键点(Key)。\n"
                f"---\n{content}\n---\n"
            )
        },
    ],
    format=fmt,
)

# 输出反馈的答案，验证答案的格式是否与前文的“json_data”期望的一致
response_json = json.loads(response.message.content)
print(json.dumps(response_json, ensure_ascii=False, indent=4))

response_format={
    'type': 'json_schema',
    'json_schema':
    {
        "schema": fmt
    }
}

    output = stdout.decode("gbk", errors="ignore")  # »ò cp936
    apu_type = ''
    if 'PCI\\VEN_1022&DEV_1502&REV_00' in output: apu_type = 'PHX/HPT'
    if 'PCI\\VEN_1022&DEV_17F0&REV_00' in output: apu_type = 'STX'
    if 'PCI\\VEN_1022&DEV_17F0&REV_10' in output: apu_type = 'STX'
    if 'PCI\\VEN_1022&DEV_17F0&REV_11' in output: apu_type = 'STX'
    if 'PCI\\VEN_1022&DEV_17F0&REV_20' in output: apu_type = 'KRK'