Mockloop MCP

🚀 MockLoop MCP - AI原生测试平台

MockLoop MCP 是由模型上下文协议（MCP）驱动的全球首个 AI 原生 API 测试平台。它凭借全面的 AI 驱动场景生成、自动化测试执行和智能分析能力，彻底改变了 API 测试方式。

• 🚀 革命性能力：5 种 AI 提示 • 15 种场景资源 • 16 种测试工具 • 10 种上下文工具 • 4 种核心工具 • 完整的 MCP 集成
• 📚 文档：https://docs.mockloop.com
• 📦 PyPI 包：https://pypi.org/project/mockloop-mcp/
• 🐙 GitHub 仓库：https://github.com/mockloop/mockloop-mcp

🚀 快速开始

使用全球最先进的 AI 原生测试平台，按以下步骤操作：

# 1. 安装 MockLoop MCP
pip install mockloop-mcp

# 2. 验证安装
mockloop-mcp --version

# 3. 使用 MCP 客户端（Cline、Claude Desktop 等）进行配置
# 请参阅下面的配置示例

✨ 主要特性

MockLoop MCP 代表了 API 测试的范式转变，引入了全球首个 AI 原生测试架构，它结合了以下特性：

• 🤖 AI 驱动的测试生成：5 个专门的 MCP 提示，用于智能场景创建
• 📦 社区场景包：15 个经过精心策划的测试资源，具备社区架构
• ⚡ 自动化测试执行：30 个全面的 MCP 工具，用于完整的测试工作流程（16 个测试工具 + 10 个上下文工具 + 4 个核心工具）
• 🔄 有状态测试：使用 GlobalContext 和 AgentContext 进行高级上下文管理
• 📊 企业合规性：完整的审计日志记录和法规合规性跟踪
• 🏗️ 双端口架构：通过分离模拟 API 和管理端口，消除 /admin 路径冲突

📦 安装指南

前提条件

• Python 3.10+
• Pip 包管理器
• Docker 和 Docker Compose（用于容器化模拟服务器）
• 兼容 MCP 的客户端（Cline、Claude Desktop 等）

选项 1：从 PyPI 安装（推荐）

# 安装最新稳定版本
pip install mockloop-mcp

# 或者安装带有可选依赖项的版本
pip install mockloop-mcp[dev]   # 开发工具
pip install mockloop-mcp[docs]  # 文档工具
pip install mockloop-mcp[all]   # 所有可选依赖项

# 验证安装
mockloop-mcp --version

选项 2：开发环境安装

# 克隆仓库
git clone https://github.com/mockloop/mockloop-mcp.git
cd mockloop-mcp

# 创建并激活虚拟环境
python3 -m venv .venv
source .venv/bin/activate  # 在 Windows 上：.venv\Scripts\activate

# 以开发模式安装
pip install -e ".[dev]"

⚙️ 配置

MCP 客户端配置

Cline（VS Code 扩展）

在 Cline MCP 设置文件中添加以下内容：

{
  "mcpServers": {
    "MockLoopLocal": {
      "autoApprove": [],
      "disabled": false,
      "timeout": 60,
      "command": "mockloop-mcp",
      "args": [],
      "transportType": "stdio"
    }
  }
}

Claude Desktop

在 Claude Desktop 配置中添加以下内容：

{
  "mcpServers": {
    "mockloop": {
      "command": "mockloop-mcp",
      "args": []
    }
  }
}

虚拟环境安装

对于虚拟环境安装，使用完整的 Python 路径：

{
  "mcpServers": {
    "MockLoopLocal": {
      "command": "/path/to/your/venv/bin/python",
      "args": ["-m", "mockloop_mcp"],
      "transportType": "stdio"
    }
  }
}

💻 使用示例

基础用法

# 1. 安装 MockLoop MCP
pip install mockloop-mcp

# 2. 验证安装
mockloop-mcp --version

高级用法

from mockloop_mcp.mcp_tools import create_mcp_plugin

# 创建一个支持代理的插件
plugin_result = await create_mcp_plugin(
    spec_url_or_path="https://api.example.com/openapi.json",
    mode="hybrid",  # 从混合模式开始
    plugin_name="example_api",
    target_url="https://api.example.com",
    auth_config={
        "auth_type": "bearer_token",
        "credentials": {"token": "your-token"}
    },
    routing_rules=[
        {
            "pattern": "/api/critical/*",
            "mode": "proxy",  # 关键端点使用实时 API
            "priority": 10
        },
        {
            "pattern": "/api/dev/*",
            "mode": "mock",   # 开发端点使用模拟数据
            "priority": 5
        }
    ]
)

📚 详细文档

可用的 MCP 工具

核心模拟生成

generate_mock_api

生成具有双端口架构的复杂 FastAPI 模拟服务器。

参数：

• spec_url_or_path（字符串，必需）：API 规范的 URL 或本地文件路径
• output_dir_name（字符串，可选）：输出目录名称
• auth_enabled（布尔值，可选）：启用身份验证中间件（默认：true）
• webhooks_enabled（布尔值，可选）：启用 Webhook 支持（默认：true）
• admin_ui_enabled（布尔值，可选）：启用管理 UI（默认：true）
• storage_enabled（布尔值，可选）：启用存储功能（默认：true）

革命性的双端口架构：

• 模拟 API 端口：提供 API 端点服务（默认：8000）
• 管理 UI 端口：独立的管理界面（默认：8001）
• 冲突解决：消除 OpenAPI 规范中的 /admin 路径冲突
• 增强的安全性：基于端口的访问控制和隔离

高级分析

query_mock_logs

使用 AI 驱动的洞察力查询和分析请求日志。

参数：

• server_url（字符串，必需）：模拟服务器 URL
• limit（整数，可选）：返回的最大日志数（默认：100）
• offset（整数，可选）：分页偏移量（默认：0）
• method（字符串，可选）：按 HTTP 方法过滤
• path_pattern（字符串，可选）：用于路径过滤的正则表达式模式
• time_from（字符串，可选）：开始时间过滤（ISO 格式）
• time_to（字符串，可选）：结束时间过滤（ISO 格式）
• include_admin（布尔值，可选）：包括管理请求（默认：false）
• analyze（布尔值，可选）：执行 AI 分析（默认：true）

AI 驱动的分析：

• 性能指标（P95/P99 响应时间）
• 错误率分析和分类
• 流量模式检测
• 自动调试建议
• 会话关联和跟踪

discover_mock_servers

支持双端口架构的智能服务器发现。

参数：

• ports（数组，可选）：要扫描的端口（默认：常用端口）
• check_health（布尔值，可选）：执行健康检查（默认：true）
• include_generated（布尔值，可选）：包括生成的模拟服务器（默认：true）

高级发现：

• 自动架构检测（单端口 vs 双端口）
• 健康状态监控
• 服务器关联和匹配
• 端口使用分析

manage_mock_data

无需重启服务器即可进行动态响应管理。

参数：

• server_url（字符串，必需）：模拟服务器 URL
• operation（字符串，必需）：操作类型（"update_response", "create_scenario", "switch_scenario", "list_scenarios"）
• endpoint_path（字符串，可选）：API 端点路径
• response_data（对象，可选）：新的响应数据
• scenario_name（字符串，可选）：场景名称
• scenario_config（对象，可选）：场景配置

动态功能：

• 实时响应更新
• 基于场景的测试
• 运行时配置管理
• 零停机修改

MCP 代理功能

MockLoop MCP 包含革命性的代理功能，可实现模拟和实时 API 环境之间的无缝切换。此强大功能为您的测试工作流程带来以下优势：

核心代理功能

• 🔄 无缝模式切换：无需更改代码即可在模拟、代理和混合模式之间切换
• 🎯 智能路由：根据可配置的规则和条件进行智能请求路由
• 🔐 通用身份验证：支持 API 密钥、Bearer 令牌、基本身份验证和 OAuth2
• 📊 响应比较：自动比较模拟和实时 API 响应
• ⚡ 零停机切换：动态更改模式，无需中断服务

操作模式

模拟模式 (MOCK)

• 所有请求由生成的模拟响应处理
• 可预测、一致的测试环境
• 适用于早期开发和隔离测试
• 无需外部依赖或网络调用

代理模式 (PROXY)

• 所有请求转发到实时 API 端点
• 实时数据和真实响应
• 完整的集成测试能力
• 依赖网络操作，需要实时凭据

混合模式 (HYBRID)

• 根据规则在模拟和代理之间进行智能路由
• 根据请求模式、标头或参数进行条件切换
• 从模拟环境逐步迁移到实时环境
• A/B 测试和选择性端点代理

AI 框架集成

LangGraph 集成

from langgraph.graph import StateGraph, END
from mockloop_mcp import MockLoopClient

# 初始化 MockLoop 客户端
mockloop = MockLoopClient()

def setup_ai_testing(state):
    """AI 驱动的测试设置"""
    # 使用 AI 分析生成模拟 API
    result = mockloop.generate_mock_api(
        spec_url_or_path="https://api.example.com/openapi.json",
        output_dir_name="ai_test_environment"
    )
    
    # 使用 AI 提示生成场景
    scenarios = mockloop.analyze_openapi_for_testing(
        api_spec=state["api_spec"],
        analysis_depth="comprehensive",
        include_security_tests=True
    )
    
    state["mock_server_url"] = "http://localhost:8000"
    state["test_scenarios"] = scenarios
    return state

def execute_ai_tests(state):
    """执行 AI 生成的测试场景"""
    # 部署 AI 生成的场景
    for scenario in state["test_scenarios"]:
        mockloop.deploy_scenario(
            server_url=state["mock_server_url"],
            scenario_config=scenario
        )
        
        # 使用 AI 优化执行负载测试
        results = mockloop.run_load_test(
            server_url=state["mock_server_url"],
            scenario_name=scenario["name"],
            duration=300,
            concurrent_users=100
        )
        
        # AI 驱动的结果分析
        analysis = mockloop.analyze_test_results(
            test_results=results,
            include_recommendations=True
        )
        
        state["test_results"].append(analysis)
    
    return state

# 构建 AI 原生测试工作流程
workflow = StateGraph(dict)
workflow.add_node("setup_ai_testing", setup_ai_testing)
workflow.add_node("execute_ai_tests", execute_ai_tests)
workflow.set_entry_point("setup_ai_testing")
workflow.add_edge("setup_ai_testing", "execute_ai_tests")
workflow.add_edge("execute_ai_tests", END)

app = workflow.compile()

CrewAI 多智能体测试

from crewai import Agent, Task, Crew
from mockloop_mcp import MockLoopClient

# 初始化 MockLoop 客户端
mockloop = MockLoopClient()

# AI 测试专家智能体
api_testing_agent = Agent(
    role='AI API Testing Specialist',
    goal='Generate and execute comprehensive AI-driven API tests',
    backstory='Expert in AI-native testing with MockLoop MCP integration',
    tools=[
        mockloop.generate_mock_api,
        mockloop.analyze_openapi_for_testing,
        mockloop.generate_scenario_config
    ]
)

# 性能分析智能体
performance_agent = Agent(
    role='AI Performance Analyst',
    goal='Analyze API performance with AI-powered insights',
    backstory='Specialist in AI-driven performance analysis and optimization',
    tools=[
        mockloop.run_load_test,
        mockloop.get_performance_metrics,
        mockloop.analyze_test_results
    ]
)

# 安全测试智能体
security_agent = Agent(
    role='AI Security Testing Expert',
    goal='Conduct AI-driven security testing and vulnerability assessment',
    backstory='Expert in AI-powered security testing methodologies',
    tools=[
        mockloop.generate_security_test_scenarios,
        mockloop.run_security_test,
        mockloop.compare_test_runs
    ]
)

# 定义 AI 驱动的任务
ai_setup_task = Task(
    description='Generate AI-native mock API with comprehensive testing scenarios',
    agent=api_testing_agent,
    expected_output='Mock server with AI-generated test scenarios deployed'
)

performance_task = Task(
    description='Execute AI-optimized performance testing and analysis',
    agent=performance_agent,
    expected_output='Comprehensive performance analysis with AI recommendations'
)

security_task = Task(
    description='Conduct AI-driven security testing and vulnerability assessment',
    agent=security_agent,
    expected_output='Security test results with AI-powered threat analysis'
)

# 创建 AI 测试团队
ai_testing_crew = Crew(
    agents=[api_testing_agent, performance_agent, security_agent],
    tasks=[ai_setup_task, performance_task, security_task],
    verbose=True
)

# 执行 AI 原生测试工作流程
results = ai_testing_crew.kickoff()

LangChain AI 测试工具

from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from mockloop_mcp import MockLoopClient

# 初始化 MockLoop 客户端
mockloop = MockLoopClient()

# AI 原生测试工具
def ai_generate_mock_api(spec_path: str) -> str:
    """Generate AI-enhanced mock API with intelligent scenarios"""
    # 生成模拟 API
    result = mockloop.generate_mock_api(spec_url_or_path=spec_path)
    
    # 使用 AI 进行分析和增强
    analysis = mockloop.analyze_openapi_for_testing(
        api_spec=spec_path,
        analysis_depth="comprehensive",
        include_security_tests=True
    )
    
    return f"AI-enhanced mock API generated: {result}\nAI Analysis: {analysis['summary']}"

def ai_execute_testing_workflow(server_url: str) -> str:
    """Execute comprehensive AI-driven testing workflow"""
    # 创建测试会话上下文
    session = mockloop.create_test_session_context(
        session_name="ai_testing_session",
        configuration={"ai_enhanced": True}
    )
    
    # 生成并部署 AI 场景
    scenarios = mockloop.generate_scenario_config(
        api_spec=server_url,
        scenario_types=["load", "error", "security"],
        ai_optimization=True
    )
    
    results = []
    for scenario in scenarios:
        # 部署场景
        mockloop.deploy_scenario(
            server_url=server_url,
            scenario_config=scenario
        )
        
        # 执行带有 AI 监控的测试
        test_result = mockloop.execute_test_plan(
            server_url=server_url,
            test_plan=scenario["test_plan"],
            ai_monitoring=True
        )
        
        results.append(test_result)
    
    # AI 驱动的分析
    analysis = mockloop.analyze_test_results(
        test_results=results,
        include_recommendations=True,
        ai_insights=True
    )
    
    return f"AI testing workflow completed: {analysis['summary']}"

# 创建 LangChain 工具
ai_testing_tools = [
    Tool(
        name="AIGenerateMockAPI",
        func=ai_generate_mock_api,
        description="Generate AI-enhanced mock API with intelligent testing scenarios"
    ),
    Tool(
        name="AIExecuteTestingWorkflow",
        func=ai_execute_testing_workflow,
        description="Execute comprehensive AI-driven testing workflow with intelligent analysis"
    )
]

# 创建 AI 测试智能体
llm = ChatOpenAI(temperature=0)
ai_testing_prompt = PromptTemplate.from_template("""
You are an AI-native testing assistant powered by MockLoop MCP.
You have access to revolutionary AI-driven testing capabilities including:
- AI-powered scenario generation
- Intelligent test execution
- Advanced performance analysis
- Security vulnerability assessment
- Stateful workflow management

Tools available: {tools}
Tool names: {tool_names}

Question: {input}
{agent_scratchpad}
""")

agent = create_react_agent(llm, ai_testing_tools, ai_testing_prompt)
agent_executor = AgentExecutor(agent=agent, tools=ai_testing_tools, verbose=True)

# 执行 AI 原生测试
response = agent_executor.invoke({
    "input": "Generate a comprehensive AI-driven testing environment for a REST API and execute full testing workflow"
})

双端口架构

MockLoop MCP 引入了革命性的 双端口架构，消除了常见冲突并增强了安全性：

架构优势

• 🔒 增强的安全性：模拟 API 和管理功能完全分离
• ⚡ 零冲突：消除 OpenAPI 规范中的 /admin 路径冲突
• 📊 清晰的分析：管理调用不会出现在模拟 API 指标中
• 🔄 独立扩展：可分别扩展模拟 API 和管理服务
• 🛡️ 基于端口的访问控制：通过网络隔离增强安全性

端口配置

# 生成具有双端口架构的模拟
result = mockloop.generate_mock_api(
    spec_url_or_path="https://api.example.com/openapi.json",
    business_port=8000,  # 模拟 API 端口
    admin_port=8001,     # 管理 UI 端口
    admin_ui_enabled=True
)

访问点

• 模拟 API：http://localhost:8000 - 您的 API 端点
• 管理 UI：http://localhost:8001 - 管理界面
• API 文档：http://localhost:8000/docs - 交互式 Swagger UI
• 健康检查：http://localhost:8000/health - 服务器状态

企业特性

合规性和审计日志记录

MockLoop MCP 提供企业级合规性特性：

• 完整的审计跟踪：每个请求/响应都记录有元数据
• 法规合规性：支持 GDPR、SOX、HIPAA 合规性
• 性能指标：P95/P99 响应时间、错误率
• 安全监控：威胁检测和分析
• 会话跟踪：跨请求关联和分析

高级分析

• AI 驱动的洞察力：智能分析和建议
• 流量模式检测：自动异常检测
• 性能优化：AI 驱动的性能建议
• 错误分析：智能错误分类和解决
• 趋势分析：历史性能和使用趋势

有状态测试工作流程

MockLoop MCP 通过高级上下文管理支持复杂的有状态测试工作流程：

上下文类型

• 测试会话上下文：在测试执行过程中维护状态
• 工作流上下文：复杂的多步骤测试编排
• 智能体上下文：AI 智能体状态管理和协调
• 全局上下文：跨会话数据共享和持久化

示例：有状态的电子商务测试

# 创建测试会话上下文
session = mockloop.create_test_session_context(
    session_name="ecommerce_integration_test",
    configuration={
        "test_type": "integration",
        "environment": "staging",
        "ai_enhanced": True
    }
)

# 创建用于多步骤测试的工作流上下文
workflow = mockloop.create_workflow_context(
    workflow_name="user_journey_test",
    parent_context=session["context_id"],
    steps=[
        "user_registration",
        "product_browsing",
        "cart_management",
        "checkout_process",
        "order_fulfillment"
    ]
)

# 执行有状态的测试工作流程
for step in workflow["steps"]:
    # 使用步骤数据更新上下文
    mockloop.update_context_data(
        context_id=workflow["context_id"],
        data={"current_step": step, "timestamp": datetime.now()}
    )
    
    # 执行特定步骤的测试
    test_result = mockloop.execute_test_plan(
        server_url="http://localhost:8000",
        test_plan=f"{step}_test_plan",
        context_id=workflow["context_id"]
    )
    
    # 创建快照以支持回滚
    snapshot = mockloop.create_context_snapshot(
        context_id=workflow["context_id"],
        snapshot_name=f"{step}_completion"
    )

# 分析完整的工作流结果
final_analysis = mockloop.analyze_test_results(
    test_results=workflow["results"],
    context_id=workflow["context_id"],
    include_recommendations=True
)

运行生成的模拟服务器

使用 Docker Compose（推荐）

# 导航到生成的模拟目录
cd generated_mocks/your_api_mock

# 使用双端口架构启动
docker-compose up --build

# 访问点：
# 模拟 API：http://localhost:8000
# 管理 UI：http://localhost:8001

直接使用 Uvicorn

# 安装依赖项
pip install -r requirements_mock.txt

# 启动模拟服务器
uvicorn main:app --reload --port 8000

增强功能访问

• 管理 UI：http://localhost:8001 - 增强的管理界面
• API 文档：http://localhost:8000/docs - 交互式 Swagger UI
• 健康检查：http://localhost:8000/health - 服务器状态和指标
• 日志分析：http://localhost:8001/api/logs/search - 高级日志查询
• 性能指标：http://localhost:8001/api/logs/analyze - AI 驱动的洞察力
• 场景管理：http://localhost:8001/api/mock-data/scenarios - 动态测试

性能和可扩展性

MockLoop MCP 专为企业级性能而设计：

性能指标

• 响应时间：跟踪 P50、P95、P99 百分位数
• 吞吐量：监控每秒请求数
• 错误率：全面的错误分析
• 资源使用：监控内存、CPU 和网络
• 并发：支持多用户负载测试

可扩展性特性

• 水平扩展：支持多实例部署
• 负载均衡：内置负载均衡功能
• 缓存：智能响应缓存
• 数据库优化：高效支持 SQLite 和 PostgreSQL
• 容器编排：支持 Kubernetes 和 Docker Swarm

安全特性

内置安全

• 身份验证中间件：可配置的身份验证机制
• 速率限制：防止滥用和 DoS 攻击
• 输入验证：全面的请求验证
• 安全标头：CORS、CSP 和安全标头
• 审计日志记录：完整的安全事件记录

安全测试

• 漏洞评估：AI 驱动的安全测试
• 渗透测试：自动生成安全场景
• 合规性检查：验证安全标准合规性
• 威胁建模：AI 驱动的威胁分析
• 安全报告：全面的安全分析

🔧 技术细节

未来开发

即将推出的功能 🚧

增强的 AI 功能

• 高级机器学习模型：自定义模型训练用于 API 测试
• 预测分析：AI 驱动的故障预测
• 智能测试生成：自我改进的测试场景
• 自然语言测试：用纯英语描述测试

扩展协议支持

• GraphQL 支持：原生 GraphQL API 测试
• gRPC 集成：支持协议缓冲区测试
• WebSocket 测试：实时通信测试
• 事件驱动测试：异步和基于事件的 API 测试

企业集成

• CI/CD 集成：原生管道集成
• 监控平台：与 Datadog、New Relic、Prometheus 集成
• 身份提供商：支持 SSO 和企业身份验证
• 合规框架：扩展法规合规支持

🤝 贡献

我们欢迎对 MockLoop MCP 的贡献！请参阅我们的 贡献指南 了解详细信息。

开发设置

# 分叉并克隆仓库
git clone https://github.com/your-username/mockloop-mcp.git
cd mockloop-mcp

# 创建开发环境
python3 -m venv .venv
source .venv/bin/activate

# 安装开发依赖项
pip install -e ".[dev]"

# 运行测试
pytest tests/

# 运行质量检查
ruff check src/
bandit -r src/

社区

• GitHub 仓库：mockloop/mockloop-mcp
• 问题和错误报告：GitHub 问题
• 功能请求：GitHub 问题
• 文档：docs.mockloop.com

📄 许可证

MockLoop MCP 根据 MIT 许可证 授权。

🎉 立即开始！

准备好使用全球首个 AI 原生测试平台彻底改变您的 API 测试了吗？

pip install mockloop-mcp

加入 AI 原生测试革命，使用 MockLoop MCP 体验 API 测试的未来！

🚀 立即开始 →