A2A + MCP：构建实用人工智能系统的超强组合

news2025/10/31 21:38:18

构建真正有效的连接型人工智能系统的挑战

如果你正在构建人工智能应用，这种情况可能听起来很熟悉：

你需要特定的人工智能能力来解决业务问题。你找到了完成每个单独任务的出色工具。但把所有东西连接在一起却占据了大部分开发时间，还创建了一个脆弱的系统，一旦有任何更改就会崩溃。

好消息是，有一个今天就能用的实用解决方案。

A2A + MCP：完美组合

在这里插入图片描述

这两个协议协同工作，解决了完整的集成挑战：

A2A（智能体到智能体） 就像是智能体的社交网络。它让它们可以直接相互沟通和协作。想象一下，你的日历智能体可以自动与你的旅行智能体协调，当航班延误时重新安排会议。

MCP（模型上下文协议） 更像是一个通用适配器。它为人工智能模型提供了标准化的方式以访问工具和数据源。它使得你的智能助手能够轻松地查看天气或搜索知识库。

A2A 处理智能体之间的通信，而 MCP 将智能体连接到它们的工具。

它们共同创建了一个清晰的双层架构，这将为你节省数百小时的开发时间。

示例图

展示如何结合 a2a 和 mcp 的示例

构建你的第一个 MCP 服务器

让我们从实际操作开始：创建一个暴露有用工具的 MCP 服务器。它有多简单，看看就知道了：

from python_a2a.mcp import FastMCP, text_response

# 创建一个新的 MCP 服务器
calculator_mcp = FastMCP(
    name="Calculator MCP",
    version="1.0.0",
    description="Provides mathematical calculation functions"
)
# 使用简单的装饰器和类型提示定义工具
@calculator_mcp.tool()
def add(a: float, b: float) -> float:
    """将两个数字相加。"""
    return a + b
@calculator_mcp.tool()
def subtract(a: float, b: float) -> float:
    """从 a 中减去 b。"""
    return a - b
@calculator_mcp.tool()
def multiply(a: float, b: float) -> float:
    """将两个数字相乘。"""
    return a * b
@calculator_mcp.tool()
def divide(a: float, b: float) -> float:
    """将 a 除以 b。"""
    if b == 0:
        return text_response("Cannot divide by zero")
    return a / b
# 运行服务器
if __name__ == "__main__":
    calculator_mcp.run(host="0.0.0.0", port=5001)

就这样——你创建了一个暴露数学运算作为标准化工具的 MCP 服务器。注意类型提示和文档字符串是如何自动成为工具接口的一部分的，这使得它们具有自我说明性。

将 MCP 工具连接到 A2A 智能体

现在，让我们创建一个使用这些 MCP 工具的 A2A 智能体：

from python_a2a import A2AServer, Message, TextContent, MessageRole, run_server
from python_a2a.mcp import FastMCPAgent

class CalculatorAgent(A2AServer, FastMCPAgent):
    """使用 MCP 工具的计算器智能体。"""

    def __init__(self):
        # 初始化父类
        A2AServer.__init__(self)
        FastMCPAgent.__init__(
            self,
            mcp_servers={"calc": "http://localhost:5001"}  # 连接到我们的 MCP 服务器
        )

    async def handle_message_async(self, message):
        """处理消息并使用 MCP 工具。"""
        try:
            if message.content.type == "text":
                text = message.content.text.lower()

                # 从消息中提取数字
                import re
                numbers = [float(n) for n in re.findall(r"[-+]?\d*\.?\d+", text)]

                if len(numbers) >= 2:
                    # 确定要执行的操作
                    if "add" in text or "plus" in text or "+" in text:
                        # 调用 MCP 工具执行计算
                        result = await self.call_mcp_tool("calc", "add", a=numbers[0], b=numbers[1])
                        return Message(
                            content=TextContent(text=f"The sum of {numbers[0]} and {numbers[1]} is {result}"),
                            role=MessageRole.AGENT,
                            parent_message_id=message.message_id,
                            conversation_id=message.conversation_id
                        )
                    elif "subtract" in text or "minus" in text or "-" in text:
                        result = await self.call_mcp_tool("calc", "subtract", a=numbers[0], b=numbers[1])
                        return Message(
                            content=TextContent(text=f"The difference between {numbers[0]} and {numbers[1]} is {result}"),
                            role=MessageRole.AGENT,
                            parent_message_id=message.message_id,
                            conversation_id=message.conversation_id
                        )
                    # 添加其他操作...

            # 默认响应
            return Message(
                content=TextContent(
                    text="I'm a calculator agent. You can ask me to add, subtract, multiply, or divide numbers."
                ),
                role=MessageRole.AGENT,
                parent_message_id=message.message_id,
                conversation_id=message.conversation_id
            )
        except Exception as e:
            # 处理错误
            return Message(
                content=TextContent(text=f"Error: {str(e)}"),
                role=MessageRole.AGENT,
                parent_message_id=message.message_id,
                conversation_id=message.conversation_id
            )
# 运行智能体
if __name__ == "__main__":
    agent = CalculatorAgent()
    run_server(agent, host="0.0.0.0", port=5000)

现在你有了一个使用 MCP 工具的 A2A 智能体。用户可以用自然语言与这个智能体互动，比如问“5 加 3 等于多少？”智能体会调用相应的 MCP 工具来计算答案。

这种做法的美妙之处在于清晰的分离：

  • MCP 服务器专注于提供计算能力
  • A2A 智能体处理自然语言理解和用户互动
  • 它们之间的连接是标准化的且无状态的

完整的实用示例：股票信息查询系统

现在让我们构建一个更有用的东西：一个帮助用户查找股票价格的股票信息查询系统，即使他们不知道股票代码也能查到。

1. 为特定工具创建 MCP 服务器

首先，我们将为两个关键能力创建 MCP 服务器：

# DuckDuckGo MCP 服务器，用于查找股票代码
duckduckgo_mcp = FastMCP(
    name="DuckDuckGo MCP",
    version="1.0.0",
    description="搜索功能，用于查找股票信息"
)

@duckduckgo_mcp.tool()
def search_ticker(company_name: str) -> str:
    """使用 DuckDuckGo 搜索查找公司的股票代码。"""
    # 实现细节（简化版）
    import requests
    import re

    query = f"{company_name} stock ticker symbol"
    url = f"https://api.duckduckgo.com/?q={query}&format=json"
    response = requests.get(url)
    data = response.json()

    # 从结果中提取代码
    # 查找类似“NYSE: AAPL”或“NASDAQ: MSFT”的模式
    text = data.get("Abstract", "")
    ticker_match = re.search(r'(?:NYSE|NASDAQ):\s*([A-Z]+)', text)
    if ticker_match:
        return ticker_match.group(1)

    # 为了演示目的，回退到常见代码
    if company_name.lower() == "apple":
        return "AAPL"
    elif company_name.lower() == "microsoft":
        return "MSFT"
    # 等等...

    return f"Could not find ticker for {company_name}"
# 在端口 5001 上运行此服务器
duckduckgo_mcp.run(port=5001)  # 在真实应用中，将其作为单独的进程运行

# YFinance MCP 服务器，用于股票价格数据
yfinance_mcp = FastMCP(
    name="YFinance MCP",
    version="1.0.0",
    description="股票市场数据工具"
)

@yfinance_mcp.tool()
def get_stock_price(ticker: str) -> dict:
    """获取给定股票代码的当前股票价格。"""
    # 实现细节
    import yfinance as yf

    try:
        # 获取股票数据
        stock = yf.Ticker(ticker)
        data = stock.history(period="1d")

        if data.empty:
            return {"error": f"No data found for ticker {ticker}"}

        # 提取价格
        price = data['Close'].iloc[-1]

        return {
            "ticker": ticker,
            "price": price,
            "currency": "USD",
            "timestamp": data.index[-1].strftime('%Y-%m-%d %H:%M:%S')
        }
    except Exception as e:
        return {"error": f"Error fetching stock data: {str(e)}"}
# 在端口 5002 上运行此服务器
yfinance_mcp.run(port=5002)  # 在真实应用中，将其作为单独的进程运行
2. 创建使用这些 MCP 工具的 A2A 智能体

现在让我们创建暴露这些能力的 A2A 智能体：

# DuckDuckGo 智能体，用于查找股票代码
class DuckDuckGoAgent(A2AServer, FastMCPAgent):
    """查找股票代码的智能体。"""

    def __init__(self):
        A2AServer.__init__(self)
        FastMCPAgent.__init__(
            self,
            mcp_servers={"search": "http://localhost:5001"}
        )

    async def handle_message_async(self, message):
        if message.content.type == "text":
            # 从消息中提取公司名称
            import re
            company_match = re.search(r"ticker\s+(?:for|of)\s+([A-Za-z\s]+)", message.content.text, re.I)
            if company_match:
                company_name = company_match.group(1).strip()
            else:
                # 默认使用整个消息
                company_name = message.content.text.strip()

            # 调用 MCP 工具查找代码
            ticker = await self.call_mcp_tool("search", "search_ticker", company_name=company_name)

            return Message(
                content=TextContent(text=f"The ticker symbol for {company_name} is {ticker}."),
                role=MessageRole.AGENT,
                parent_message_id=message.message_id,
                conversation_id=message.conversation_id
            )

        # 处理其他消息类型或错误
        return Message(
            content=TextContent(text="I can help find ticker symbols for companies."),
            role=MessageRole.AGENT,
            parent_message_id=message.message_id,
            conversation_id=message.conversation_id
        )
# 在端口 5003 上运行此智能体
run_server(DuckDuckGoAgent(), port=5003)  # 在真实应用中，将其作为单独的进程运行
# YFinance 智能体，用于股票价格
class YFinanceAgent(A2AServer, FastMCPAgent):
    """提供股票价格信息的智能体。"""

    def __init__(self):
        A2AServer.__init__(self)
        FastMCPAgent.__init__(
            self,
            mcp_servers={"finance": "http://localhost:5002"}
        )

    async def handle_message_async(self, message):
        if message.content.type == "text":
            # 从消息中提取代码
            import re
            ticker_match = re.search(r"\b([A-Z]{1,5})\b", message.content.text)
            if ticker_match:
                ticker = ticker_match.group(1)

                # 调用 MCP 工具获取价格
                price_info = await self.call_mcp_tool("finance", "get_stock_price", ticker=ticker)

                if "error" in price_info:
                    return Message(
                        content=TextContent(text=f"Error getting price for {ticker}: {price_info['error']}"),
                        role=MessageRole.AGENT,
                        parent_message_id=message.message_id,
                        conversation_id=message.conversation_id
                    )

                return Message(
                    content=TextContent(
                        text=f"{ticker} is currently trading at {price_info['price']:.2f} {price_info['currency']}."
                    ),
                    role=MessageRole.AGENT,
                    parent_message_id=message.message_id,
                    conversation_id=message.conversation_id
                )

        # 处理其他消息类型或错误
        return Message(
            content=TextContent(text="I can provide stock price information for ticker symbols."),
            role=MessageRole.AGENT,
            parent_message_id=message.message_id,
            conversation_id=message.conversation_id
        )
# 在端口 5004 上运行此智能体
run_server(YFinanceAgent(), port=5004)  # 在真实应用中，将其作为单独的进程运行
3. 创建一个协调器来整合这些能力

最后，让我们创建一个股票助手，整合这些专业智能体，提供无缝体验：

from python_a2a import A2AClient, Message, TextContent, MessageRole, OpenAIA2AServer, run_server
import re
import os

class StockAssistant(OpenAIA2AServer):
    """一个股票信息助手，协调专业智能体。"""

    def __init__(self, api_key, duckduckgo_endpoint, yfinance_endpoint):
        # 初始化 OpenAI 驱动的智能体
        super().__init__(
            api_key=api_key,
            model="gpt-3.5-turbo",
            system_prompt=(
                "You are a helpful financial assistant that helps users get stock information. "
                "You extract company names from user queries to find ticker symbols and prices."
            )
        )

        # 创建连接到专业智能体的客户端
        self.duckduckgo_client = A2AClient(duckduckgo_endpoint)
        self.yfinance_client = A2AClient(yfinance_endpoint)

    def handle_message(self, message):
        """覆盖以拦截股票相关查询。"""
        if message.content.type == "text":
            text = message.content.text.lower()

            # 检查这是否是股票价格查询
            if ("stock" in text or "price" in text or "trading" in text) and any(company in text for company in ["apple", "microsoft", "google", "amazon", "tesla", "facebook", "meta"]):
                # 将其作为股票查询处理
                return self._get_stock_info(message)

        # 对于所有其他消息，委托给 OpenAI
        return super().handle_message(message)

    def _get_stock_info(self, message):
        """通过协调专业智能体处理股票信息查询。"""
        try:
            # 首先，使用 OpenAI 提取公司名称
            openai_response = super().handle_message(Message(
                content=TextContent(
                    text=f"Extract only the company name from this query: '{message.content.text}'. "
                         f"Return ONLY the company name, nothing else."
                ),
                role=MessageRole.USER
            ))

            company_name = openai_response.content.text.strip()
            company_name = company_name.strip('"\'.,')

            # 第一步：从 DuckDuckGo 智能体获取股票代码
            ticker_message = Message(
                content=TextContent(text=f"What's the ticker for {company_name}?"),
                role=MessageRole.USER
            )
            ticker_response = self.duckduckgo_client.send_message(ticker_message)

            # 从响应中提取代码
            ticker_match = re.search(r'ticker\s+(?:symbol\s+)?(?:for\s+[\w\s]+\s+)?is\s+([A-Z]{1,5})',
                                   ticker_response.content.text, re.I)
            if not ticker_match:
                return Message(
                    content=TextContent(text=f"I couldn't find the ticker symbol for {company_name}."),
                    role=MessageRole.AGENT,
                    parent_message_id=message.message_id,
                    conversation_id=message.conversation_id
                )

            ticker = ticker_match.group(1)

            # 第二步：从 YFinance 智能体获取股票价格
            price_message = Message(
                content=TextContent(text=f"What's the current price of {ticker}?"),
                role=MessageRole.USER
            )
            price_response = self.yfinance_client.send_message(price_message)

            # 返回合并后的信息
            return Message(
                content=TextContent(
                    text=f"{company_name} ({ticker}): {price_response.content.text}"
                ),
                role=MessageRole.AGENT,
                parent_message_id=message.message_id,
                conversation_id=message.conversation_id
            )

        except Exception as e:
            # 处理任何错误
            return Message(
                content=TextContent(text=f"Sorry, I encountered an error: {str(e)}"),
                role=MessageRole.AGENT,
                parent_message_id=message.message_id,
                conversation_id=message.conversation_id
            )
# 运行助手
if __name__ == "__main__":
    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        print("Error: OPENAI_API_KEY environment variable is required")
        exit(1)

    assistant = StockAssistant(
        api_key=api_key,
        duckduckgo_endpoint="http://localhost:5003/a2a",
        yfinance_endpoint="http://localhost:5004/a2a"
    )

    run_server(assistant, port=5000)
4. 创建一个简单的客户端供用户使用

最后，让我们创建一个客户端，方便用户与我们的系统互动：

from python_a2a import A2AClient, Message, TextContent, MessageRole
import argparse

def interactive_session(client):
    """与股票助手的交互式会话。"""
    print("\n===== Stock Price Assistant =====")
    print("Type 'exit' or 'quit' to end the session.")
    print("Example queries:")
    print("  - What's the stock price of Apple?")
    print("  - How much is Microsoft trading for?")
    print("  - Get the current price of Tesla stock")
    print("=" * 50)

    while True:
        try:
            user_input = input("\n> ")

            if user_input.lower() in ["exit", "quit"]:
                print("Goodbye!")
                break

            # 以文本消息发送
            message = Message(
                content=TextContent(text=user_input),
                role=MessageRole.USER
            )

            print("Sending to assistant...")
            response = client.send_message(message)

            # 显示响应
            print(f"\nAssistant: {response.content.text}")

        except Exception as e:
            print(f"Error: {e}")
            print("Please try again or type 'exit' to quit.")
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Stock Assistant Client")
    parser.add_argument("--endpoint", default="http://localhost:5000/a2a",
                        help="Stock assistant endpoint URL")

    args = parser.parse_args()

    # 创建客户端
    client = A2AClient(args.endpoint)

    # 开始交互式会话
    interactive_session(client)

这种架构为你创造的价值

这种 A2A + MCP 架构今天就能带来实实在在的实用价值：

  1. 大幅减少集成工作：无需为每个服务编写自定义连接器——一切都能说同一种语言。
  2. 轻松替换组件：需要更好的数据源？只需插入一个新的智能体——协调器保持不变。
  3. 清晰的错误边界：每个智能体处理自己的错误，防止系统性故障。
  4. 简单可扩展：想添加历史数据？只需创建一个新的 MCP 工具，并通过新的或现有的智能体暴露它。
  5. 跨项目复用组件：那个 DuckDuckGo 智能体可以在任何需要搜索功能的项目中使用。

今天就能运行这个系统

你可以按照以下步骤今天就运行这个完整的股票信息查询系统：

设置你的环境：

# 安装必要的包

pip install "python-a2a[all]" yfinance requests

启动每个组件（在单独的终端中）：

# 启动 MCP 服务器
python duckduckgo_mcp_server.py
python yfinance_mcp_server.py

# 启动 A2A 智能体
python duckduckgo_agent.py
python yfinance_agent.py

# 启动协调器（替换为你的 API 密钥） OPENAI_API_KEY=your_key_here
python stock_assistant.py  # 运行客户端 python stock_client.py

通过客户端与系统互动：

> What's the current stock price of Apple?
Assistant: Apple (AAPL): AAPL is currently trading at 173.58 USD.

你可以立即解决的三个真实业务问题

这种架构模式可以立即解决许多业务问题。以下是三个例子：

1. 客户支持自动化

问题：支持团队需要访问多个后端系统来回答客户问题。

A2A + MCP 解决方案：

  • 为每个后端系统创建 MCP 工具（订单、产品、运输）
  • 构建每个领域的专业 A2A 智能体
  • 创建一个协调器，路由问题并聚合答案

创造的价值：

  • 支持代理可以在一个地方获得完整的信息
  • 后端系统保持隔离但可访问
  • 添加新的数据源无需重新训练整个系统
2. 文档处理流程

问题：处理文档需要多个专业步骤（OCR、提取、分类）。

A2A + MCP 解决方案：

  • 为每个处理步骤创建 MCP 工具
  • 构建专门处理不同文档类型的 A2A 智能体
  • 创建一个协调器来管理工作流

创造的价值：

  • 文档处理步骤之间有清晰的分离
  • 不同文档类型的专业处理
  • 容易添加对新文档格式的支持
3.研究助理：

问题：研究人员需要查询文献、分析数据并应用领域知识。

A2A + MCP 解决方案：

  • 创建用于文献搜索、数据分析和领域特定计算的 MCP 工具。
  • 构建专门处理不同研究领域的 A2A 智能体。
  • 创建一个协调器来处理复杂的查询请求。

创造的价值：

  • 研究人员可以从多个来源获得全面的答案。
  • 正确应用领域特定的计算。
  • 添加新的研究方法不会破坏现有功能。

如何构建你自己的 A2A + MCP 系统

你可以立即开始实现这种架构，只需按照以下步骤操作：

确定你的能力需求：

  • 你需要哪些工具或数据源？
  • 涉及哪些专业领域知识？

为每种能力创建 MCP 工具：

  • 定义清晰的接口，并使用类型提示。
  • 使用适当的错误处理。
  • 让每个工具专注于一种能力。

构建使用这些工具的 A2A 智能体：

  • 每个智能体应专注于一个领域。
  • 使用 MCP 来访问工具。
  • 通过 A2A 暴露能力。

创建协调各个智能体的协调器：

  • 路由查询请求到适当的智能体。
  • 将结果合并成连贯的响应。
  • 管理对话流程。

构建用户友好的客户端：

  • 通过 A2A 连接到协调器。
  • 清晰地向用户展示信息。
  • 优雅地处理错误。

总结

A2A + MCP 不仅仅是一个理论架构，它是一个今天就可以实现的实用解决方案，用于解决真实业务问题。通过标准化智能体通信和工具集成，你可以构建出：

  • 模块化：易于扩展和维护。
  • 可靠：清晰的错误边界和稳健的通信。
  • 灵活：组件可以独立替换或升级。
  • 可复用：工具和智能体可以在多个项目中共享。

别再浪费时间构建自定义集成，A2A + MCP 已经提供了一个经过验证的解决方案。

今天就试试看吧

Python A2A 库现在已经完全支持 MCP。你可以立即开始使用：

pip install "python-a2a[mcp]"

查看 GitHub 上的完整示例，了解 A2A + MCP 的实际运行情况，或者使用本文中的代码构建你的第一个集成人工智能系统。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2340794.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

力扣每日打卡17 49. 字母异位词分组 (中等)

力扣每日打卡17 49. 字母异位词分组 (中等)

力扣 49. 字母异位词分组 中等 前言一、题目内容二、解题方法1. 哈希函数2.官方题解2.1 前言2.2 方法一：排序2.2 方法二：计数 前言 这是刷算法题的第十七天，用到的语言是JS 题目：力扣 49. 字母异位词分组 (中等) 一、题目内容 给…
阅读更多...
Word处理控件Spire.Doc系列教程：C# 为 Word 文档设置背景颜色或背景图片

Word处理控件Spire.Doc系列教程：C# 为 Word 文档设置背景颜色或背景图片

在 Word 文档中，白色是默认的背景设置。一般情况下，简洁的白色背景足以满足绝大多数场景的使用需求。但是，如果您需要创建简历、宣传册或其他创意文档，设置独特的背景颜色或图片能够极大地增强文档的视觉冲击力。本文将演示如何使…
阅读更多...
掌握 Altium Designer：轻松定制“交换器件”工具栏

掌握 Altium Designer：轻松定制“交换器件”工具栏

在PCB设计过程中，快速交换器件（如电阻、电容、IC等）是提高效率的关键。Altium Designer提供了灵活的工具栏定制功能，让用户可以创建专属的"交换器件"工具栏，将常用操作集中管理，减少菜单切换时间…
阅读更多...
【C++ Qt】信号和槽（内配思维导图 图文并茂 通俗易懂）

【C++ Qt】信号和槽（内配思维导图 图文并茂 通俗易懂）

每日激励：“不设限和自我肯定的心态：I can do all things。 — Stephen Curry” 绪论​： 本章是Qt中的第三章，也是我们理解Qt中必备的点 信号槽，它本质由信号和槽两个来实现，其中将细致的讲述如何自定义信号…
阅读更多...
从零开始构建微博爬虫：实现自动获取并保存微博内容

从零开始构建微博爬虫：实现自动获取并保存微博内容

从零开始构建微博爬虫：实现自动获取并保存微博内容 前言 在信息爆炸的时代，社交媒体平台已经成为信息传播的重要渠道，其中微博作为中国最大的社交媒体平台之一，包含了大量有价值的信息和数据。对于研究人员、数据分析师或者只是…
阅读更多...
三餐四季、灯火阑珊

三餐四季、灯火阑珊

2025年4月22日，15~28℃，挺好的 待办： 教学技能大赛教案（2025年4月24日，校赛，小组合作，其他成员给力，暂不影响校赛进度，搁置） 教学技能大赛PPT（202…
阅读更多...
基于javaweb的SSM+Maven教材管理系统设计与实现(源码+文档+部署讲解）

基于javaweb的SSM+Maven教材管理系统设计与实现(源码+文档+部署讲解）

技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等设计与开发。 主要内容：免费功能设计、开题报告、任务书、中期检查PPT、系统功能实现、代码编写、论文编写和辅导、论文…
阅读更多...
NineData 与飞书深度集成，企业级数据管理审批流程全面自动化

NineData 与飞书深度集成，企业级数据管理审批流程全面自动化

NineData 正式推出与飞书审批系统的深度集成功能，企业用户在 NineData 平台发起的审批工单，将自动推送至审批人的飞书中，审批人可以直接在飞书进行审批并通过/拒绝。该功能实现跨系统协作，带来巨大的审批效率提升，为各…
阅读更多...
mockMvc构建web单元测试学习笔记

mockMvc构建web单元测试学习笔记

web应用本来需要依靠tomcat这个环境运行 现在用mockMvc是为了模拟这个web环境，简化测试 什么是mock(模拟) 模拟对象---mock object是以可控方式模拟真实对象行为的假对象，通过模拟输入数据，验证程序达到预期结果 为什么使用mock对象 因为…
阅读更多...
Windows7升级Windows10，无法在此驱动器上安装Windows

Windows7升级Windows10，无法在此驱动器上安装Windows

一、现象描述 台式机工作站，从Windows7升级Windows10，采用MediaCreationTool_22H2制作U盘启动盘，安装系统遇到问题如下： 二、原因分析 是由于硬盘格式不是GPT硬盘，而Windows系统只能安装到GPT硬盘上，所以…
阅读更多...
Idea创建项目的搭建

Idea创建项目的搭建

1、普通java项目 如果没有project SDK去new，默认在C:\Program Files\Java\jdk1.8.0_261 输入项目名称和项目路径 点击完成，即创建好一个普通的Java项目。 2、普通JavaWEB项目 目录中没有WEB-INF文件可以直接从tomcat中粘贴过来 D:\apache-tomcat-8.5.…
阅读更多...
GpuGeek：以弹性算力与全栈服务赋能产业智能升级

GpuGeek：以弹性算力与全栈服务赋能产业智能升级

在人工智能技术快速融入各领域的趋势下，企业对高效、低成本的AI基础设施需求日益迫切。GpuGeek作为一站式AI基础设施平台，凭借其弹性算力调度、全流程开发支持、全球化资源覆盖以及国产化技术适配四大核心优势，为产业智能化升级提供了坚实的技…
阅读更多...
网络原理 - 4（TCP - 1）

网络原理 - 4（TCP - 1）

目录 TCP 协议 TCP 协议段格式 可靠传输 几个 TCP 协议中的机制 1. 确认应答 2. 超时重传 完！ TCP 协议 TCP 全称为 “传输控制协议”（Transmission Control Protocol），要对数据的传输进行一个详细的控制。 TCP 协议段格…
阅读更多...
强化学习框架：OpenRLHF源码解读，模型处理

强化学习框架：OpenRLHF源码解读，模型处理

本文主要介绍 强化学习框架：OpenRLHF源码解读，模型处理 models框架设计 了解一下 OpenRLHF的模型框架设计范式： From:https://arxiv.org/pdf/2405.11143 可以知道一个大概的流程：输入Pormpt通过Actor model输出回复 Response&am…
阅读更多...
STL常用算法——C++

STL常用算法——C++

1.概述 2.常用遍历算法 1.简介 2.for_each 方式一&#xff1a;传入普通函数&#xff08;printf1&#xff09; #include<stdio.h> using namespace std; #include<string> #include<vector> #include<functional> #include<algorithm> #include…
阅读更多...
UofTCTF-2025-web-复现

UofTCTF-2025-web-复现

感兴趣朋友可以去我博客里看&#xff0c;画风更好看 UofTCTF-2025-web-复现 文章目录 scavenger-huntprismatic-blogscode-dbprepared-1prepared-2timeless scavenger-hunt 国外的一些ctf简单题就喜欢把flag藏在注释里&#xff0c;开源代码找到第一部分的flag 抓个包返回数据…
阅读更多...
[密码学基础]GB与GM国密标准深度解析：定位、差异与协同发展

[密码学基础]GB与GM国密标准深度解析：定位、差异与协同发展

[密码学基础]GB与GM国密标准深度解析&#xff1a;定位、差异与协同发展 导语 在国产密码技术自主可控的浪潮下&#xff0c;GB&#xff08;国家标准&#xff09;与GM&#xff08;密码行业标准&#xff09;共同构建了我国商用密码的技术规范体系。二者在制定主体、法律效力、技术…
阅读更多...
15.第二阶段x64游戏实战-分析怪物血量（遍历周围）

15.第二阶段x64游戏实战-分析怪物血量（遍历周围）

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 本次游戏没法给 内容参考于&#xff1a;微尘网络安全 上一个内容&#xff1a;14.第二阶段x64游戏实战-分析人物的名字 如果想实现自动打怪&#xff0c;那肯定…
阅读更多...
HarmonyOS 基础语法概述 UI范式

HarmonyOS 基础语法概述 UI范式

ArkUI框架 - UI范式 ArkTS的基本组成 装饰器&#xff1a; 用于装饰类、结构、方法以及变量&#xff0c;并赋予其特殊的含义。如上述示例中Entry、Component和State都是装饰器&#xff0c;Component表示自定义组件&#xff0c;Entry表示该自定义组件为入口组件&#xff0c;Stat…
阅读更多...
专题讨论2：树与查找

专题讨论2：树与查找

在讨论前先回顾一下定义&#xff1a; BST树的定义 二叉搜索树是一种特殊的二叉树&#xff0c;对于树中的任意一个节点&#xff1a; 若它存在左子树&#xff0c;那么左子树中所有节点的值都小于该节点的值。 若它存在右子树&#xff0c;那么右子树中所有节点的值都大于该节点…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023